/export/development/ViennaData/release/ViennaData-1.0.1/viennadata/data_container.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_DATA_CONTAINER_HPP
#define VIENNADATA_DATA_CONTAINER_HPP


#include <map>

#include "viennadata/forwards.h"
#include "viennadata/config/object_identifier.hpp"
#include "viennadata/traits/data_container.hpp"
#include "viennadata/key_value_registration.hpp"

namespace viennadata
{

  template <typename KeyType,
            typename DataType,
            typename ObjectType>
  class data_container
  {
    private:
      typedef typename traits::container<KeyType, DataType, ObjectType>::container_type    container_type;

      container_type container; 

      data_container() {}
      data_container(data_container const & other) {}
      ~data_container() {}

    public:
      typedef typename traits::data_type_reference<DataType, container_type>::type         reference;                                  
      
      static data_container & instance()
      {
        static data_container * da = NULL;
        if (da == NULL)
        {
          da = new data_container();
          key_value_registration<ObjectType>::instance().template add<KeyType, DataType>();
        }

        return *da;
      }

      reference access(ObjectType const & obj,
                        KeyType const & key)
      {
        return traits::container<KeyType, DataType, ObjectType>::access(container, obj, key);
      }

      reference access(ObjectType const & obj)
      {
        return traits::container<KeyType, DataType, ObjectType>::access(container, obj);
      }

      
      //multiple copy - stage 1: this is the source, forward the request to the destination:
      template <typename ObjectDestType>
      void copy(ObjectType const & obj_src,
                ObjectDestType const & obj_dest)
      {
        data_container<KeyType, DataType, ObjectDestType>::instance().copy(container, obj_src, obj_dest);
      }
      
      
      //multiple copy - stage 2: this is the destination: Perform the copy
      template <typename ContainerSrcType,
                typename ObjectSrcType>
      void copy(ContainerSrcType & cont_src,
                ObjectSrcType const & obj_src,
                ObjectType const & obj_dest)
      {
        traits::container<KeyType, DataType, ObjectType>::copy(cont_src, obj_src, container, obj_dest);
      }


      void erase(ObjectType const & obj,
                 KeyType const & key)
      {
        traits::container<KeyType, DataType, ObjectType>::erase(container, obj, key);
      }

      // erase data associated with all keys of key_type
      void erase(ObjectType const & obj)
      {
        traits::container<KeyType, DataType, ObjectType>::erase(container, obj);
      }

      // reserve memory if a vector type is used
      void reserve(long num)
      {
        //std::cout << "Reserving..." << std::endl;
        traits::container<KeyType, DataType, ObjectType>::reserve(container, num);
      }
      
      DataType * find(ObjectType const & obj,
                      KeyType const & key)
      {
        return traits::container<KeyType, DataType, ObjectType>::find(container, obj, key);
      }

      DataType * find(ObjectType const & obj)
      {
        return traits::container<KeyType, DataType, ObjectType>::find(container, obj);
      }

  };

} // namespace viennadata

#endif