/export/development/ViennaData/release/ViennaData-1.0.1/viennadata/key_value_registration.hpp

Go to the documentation of this file.

/* =======================================================================
   Copyright (c) 2010, Institute for Microelectronics, TU Vienna.
   http://www.iue.tuwien.ac.at
                             -----------------
                     ViennaData - The Vienna Data Storage Library
                             -----------------

   authors:    Karl Rupp                          rupp@iue.tuwien.ac.at

   license:    MIT (X11), see file LICENSE in the ViennaMesh base directory
======================================================================= */


  /******************* ID Handling *******************************/

#ifndef VIENNADATA_KEY_VALUE_REGISTRATION_HPP
#define VIENNADATA_KEY_VALUE_REGISTRATION_HPP

#include <assert.h>
#include <map>
#include <vector>
#include <list>
#include <set>
#include <iostream>
#include <algorithm>
#include <memory>

#include "viennadata/key_value_pair.hpp"


namespace viennadata
{
  template <typename ObjectType>
  class key_value_registration
  {
      typedef std::vector<key_value_pair<ObjectType> >       container_type;

      key_value_registration() {}
      key_value_registration(key_value_registration const &) {}
      ~key_value_registration() {}
      
    public:

      static key_value_registration & instance()
      {
        static key_value_registration * kvr = NULL;
        if (kvr == NULL)
          kvr = new key_value_registration();

        return *kvr;
      }

      template <typename KeyType,
                typename DataType>
      void add()
      {
        key_value_pair<ObjectType> kve;
        kve.template add<KeyType, DataType>();

        //search whether already registered:
        if (std::find(container.begin(), container.end(), kve) == container.end())
          container.push_back(kve);
      }

/*      template <typename key_type, typename value_type>
      void remove()
      {
        typedef typename container_type::iterator   ContIter;

        key_value_pair<object_type> kve;
        kve.template add<key_type, value_type>();

        ContIter ci = std::find(container.begin(), container.end(), kve);
        if (ci != container.end())
          container.erase(ci);
      }*/


      template <typename KeyType>
      void erase_key_all(ObjectType const & obj) const
      {
        typedef typename container_type::const_iterator   ContIter;

        key_value_pair<ObjectType> kve;
        kve.template add<KeyType, all>();

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
          if (*it == kve)
            it->erase(obj);
        }
      }

      template <typename DataType>
      void erase_all_value(ObjectType const & obj) const
      {
        typedef typename container_type::const_iterator   ContIter;

        key_value_pair<ObjectType> kve;
        kve.template add<all, DataType>();

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
          if (*it == kve)
            it->erase(obj);
        }
      }

      void erase_all_all(ObjectType const & obj) const
      {
        typedef typename container_type::const_iterator   ContIter;

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
            it->erase(obj);
        }
      }



      template <typename KeyType>
      void copy_key_all(ObjectType const & src,
                        ObjectType const & dest) const
      {
        typedef typename container_type::const_iterator   ContIter;

        key_value_pair<ObjectType> kve;
        kve.template add<KeyType, all>();

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
          if (*it == kve)
            it->copy(src, dest);
        }
      }

      template <typename value_type>
      void copy_all_value(ObjectType const & src,
                          ObjectType const & dest) const
      {
        typedef typename container_type::const_iterator   ContIter;

        key_value_pair<ObjectType> kve;
        kve.template add<all, value_type>();

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
          if (*it == kve)
            it->copy(src, dest);
        }
      }

      void copy_all_all(ObjectType const & src,
                        ObjectType const & dest) const
      {
        typedef typename container_type::const_iterator   ContIter;

        for (ContIter it = container.begin();
             it != container.end();
             ++it)
        {
            it->copy(src, dest);
        }
      }


    private:
      container_type container;
  };

}

#endif