MultiTypeMap.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLUtils/src/ICLUtils/MultiTypeMap.h                   **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <ICLUtils/Mutex.h>
#include <ICLUtils/SmartPtr.h>

#include <string>
#include <map>
#include <typeinfo>
#include <cstdio>
#include <vector>

namespace icl{
  namespace utils{
    

    class ICLUtils_API MultiTypeMap{
      public:
      MultiTypeMap();
      
      ~MultiTypeMap();
      
      template<class T>
      static inline const std::string &get_type_name(){
        static std::string NAME = typeid(T).name();
        return NAME;
      }
     

      template<class T>
      inline T *allocArray(const std::string &id,unsigned int n){
        if(!n){
          ERROR_LOG("unable to create an array of size 0 for id " << id << "!");
          return 0;
        }
        if(contains(id)){
          ERROR_LOG("id " << id << "is already defined");
          return 0;
        }
        DataArray &da = (*m_oDataMapPtr)[id];
        da.data = new T[n];
        da.len = n;
        da.type = get_type_name<T>();
        da.release_func = DataArray::release_data_array<T>;
        return reinterpret_cast<T*>(da.data);
      }
      

      template<class T>
      inline T &allocValue(const std::string &id, const T &val=T()){
        static T _NULL = T();
        if(contains(id)){
          ERROR_LOG("id " << id << "is already defined");
          return _NULL;
        }
        DataArray &da = (*m_oDataMapPtr)[id];
        da.data = new T(val);
        da.len = 0; // indicates a single value !
        da.type = get_type_name<T>();
  
        da.release_func = DataArray::release_data_array<T>;
        return *(reinterpret_cast<T*>(da.data));
      }
      

      template<class T>
      inline void release(const std::string &id){
        if(!contains(id)){
          ERROR_LOG("id "<<  id  << " not found \n");
          return;
        }
        DataArray &da = (*m_oDataMapPtr)[id];
        if(da.type != get_type_name<T>()){
          ERROR_LOG("unable to cast "<<  id  << " to a given type "<< get_type_name<T>() <<"\n");
          ERROR_LOG("type is " << da.type << "\n");
          return;
        }
        da.release_func(&da);
        m_oDataMapPtr->erase(m_oDataMapPtr->find(id));
      }
      

      template<class T>
      inline T* getArray(const std::string &id, int *lenDst=0){
        if(!contains(id)){
          ERROR_LOG("id "<<  id  << " not found \n");
          return 0;
        }
  
        DataArray &da = (*m_oDataMapPtr)[id];
  
        if(da.type != get_type_name<T>()){
          ERROR_LOG("unable to cast "<<  id  << " to a given type "<< get_type_name<T>() <<"\n");
          return 0;
        }
        if(!da.len){
          ERROR_LOG("unable to access entry " << id << " as array, because it is a value!");
          return 0;
        }
        if(lenDst) *lenDst = da.len;
        return reinterpret_cast<T*>(da.data);
      }
     

      template<class T>
      inline T &getValue(const std::string &id, bool checkType=true){
        static T _NULL;
        if(!contains(id)){
          ERROR_LOG("id "<<  id  << " not found \n");
          return _NULL;
        }
  
        // orig
        DataArray &da = (*m_oDataMapPtr)[id];
        //DEBUG_LOG("type of da is " << da.type);
        if(checkType && (da.type != get_type_name<T>())){
          ERROR_LOG("unable to cast "<<  id  << " to a given type "<< get_type_name<T>() <<"\n");
          ERROR_LOG("type is " << da.type << "\n");
          return _NULL;
        }
        if(da.len){
          ERROR_LOG("unable to access entry " << id << " as value, because it is an array!");
          return _NULL;
        }
        return *reinterpret_cast<T*>(da.data);
      }
        
      template<class T>
      inline const T &getValue(const std::string &id, bool checkType=true) const{
        return const_cast<MultiTypeMap*>(this)->getValue<T>(id,checkType);
      }
  
     
      

      const std::string &getType(const std::string &id) const;
      

      template<class T>
      inline bool checkType(const std::string &id) const{
        return check_type_internal(id,get_type_name<T>());
      }
      

      bool isArray(const std::string &id) const;
      

      bool contains(const std::string &id) const;
  
      
      // internally locks the datastore
      inline void lock() const { m_oMutexPtr->lock(); }
      
      inline void unlock() const { m_oMutexPtr->unlock(); }
      protected:
  
      bool check_type_internal(const std::string &id, const std::string &typestr) const;
      
      struct DataArray{
        

        template<class T>
        static void release_data_array(DataArray *da){
          ICLASSERT_RETURN(da->type == get_type_name<T>());
          if(da->len) delete [] reinterpret_cast<T*>(da->data);
          else delete reinterpret_cast<T*>(da->data);
        }
        DataArray(void *data=0, int len=0):data(data),len(len),type(""),release_func(0){}
        void *data; //<! identified using the type string
        int len;    //<! length of the data array or 0 if it was created using () instead of []
        std::string type; //<! created using RTTI
        void (*release_func)(DataArray*); //<! data release function called by the parent MultiTypeMap object
      };
      
      public:
      void listContents() const;
  
      // removes all data from this data store
      void clear();
  
      
      struct Entry{
        Entry(){}
        Entry(const std::string &key,const std::string &type, int len):
          key(key),type(type),len(len){}
        std::string key;
        std::string type;
        int len;
      };
      
      std::vector<Entry> getEntryList() const;
  
      protected:
  
      typedef std::map<std::string,DataArray> DataMap;
  
      typedef SmartPtr<DataMap> SmartDataMapPtr;
      
      typedef SmartPtr<Mutex> SmartMutexPtr;
   
      mutable SmartDataMapPtr m_oDataMapPtr;
      
      mutable SmartMutexPtr m_oMutexPtr;
    };
  } // namespace utils
}