/export/development/ViennaData/release/ViennaData-1.0.1/viennadata/key_value_pair.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 ViennaData base directory
======================================================================= */



#ifndef VIENNADATA_KEY_VALUE_MANAGER_HPP
#define VIENNADATA_KEY_VALUE_MANAGER_HPP

#include <map>
#include <vector>
#include <list>
#include <set>
#include <iostream>
#include <algorithm>
#include <memory>

#include "viennadata/data_container.hpp"
#include "viennadata/forwards.h"

namespace viennadata
{

  template <typename ObjectType>
  class key_value_pair_interface
  {
    public:
      virtual ~key_value_pair_interface() {};

      virtual void copy(ObjectType const & src, ObjectType const & dest) const = 0;
      
      virtual void erase(ObjectType const & src) const = 0;
      
      virtual bool operator==(key_value_pair_interface<ObjectType> const &) const = 0;
  };


  template <typename KeyType,
            typename DataType,
            typename ObjectType>
  class key_value_pair_wrapper : public key_value_pair_interface<ObjectType>
  {
      typedef key_value_pair_wrapper<KeyType, DataType, ObjectType>      self_type;
      typedef key_value_pair_wrapper<KeyType, all, ObjectType>           self_type_key_all;
      typedef key_value_pair_wrapper<all, DataType, ObjectType>          self_type_all_value;
      typedef key_value_pair_wrapper<all, all, ObjectType>               self_type_all_all;

    public:
      void copy(ObjectType const & src,
                ObjectType const & dest) const
      {
        data_container<KeyType, DataType, ObjectType>::instance().copy(src, dest);
      }

      void erase(ObjectType const & src) const
      {
        data_container<KeyType, DataType, ObjectType>::instance().erase(src);
      }

      bool operator==(key_value_pair_interface<ObjectType> const & other) const
      {
        return (dynamic_cast< self_type const *>( &other ) != NULL
                || dynamic_cast< self_type_key_all const *>( &other ) != NULL
                || dynamic_cast< self_type_all_value const *>( &other ) != NULL
                || dynamic_cast< self_type_all_all const *>( &other ) != NULL);
      }

  };


  template <typename ObjectType>
  class key_value_pair
  {
    public:
      key_value_pair() : key_value(NULL), owner(false) {};

      key_value_pair(key_value_pair const & other)
      {
        key_value = other.key_value;
        owner = true;
        other.owner = false;
      }

      ~key_value_pair()
      {
        if (owner && key_value != NULL)
          delete key_value;
      }

      bool operator==(key_value_pair<ObjectType> const & other) const
      {
        return *key_value == *(other.key_value);
      }

      template <typename KeyType, typename DataType>
      void add()
      {
        assert(key_value == NULL);
        key_value = new key_value_pair_wrapper<KeyType, DataType, ObjectType>();
      }

      void copy(ObjectType const & src,
                ObjectType const & dest) const
      {
        key_value->copy(src, dest);
      }

      void erase(ObjectType const & el) const
      {
        key_value->erase(el);
      }

    private:
      key_value_pair_interface<ObjectType> * key_value;
      mutable bool owner; 
  };



}

#endif