DataStore.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   : ICLQt/src/ICLQt/DataStore.h                            **
** Module : ICLQt                                                  **
** 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.GPL  **
** 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/MultiTypeMap.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/Function.h>
#include <ICLUtils/StringUtils.h>
#include <ICLQt/MouseEvent.h>

namespace icl{
  namespace qt{
  
   

    class DataStore : public utils::MultiTypeMap{
      public:
  
      struct KeyNotFoundException : public utils::ICLException{
        KeyNotFoundException(const std::string &key):utils::ICLException("Key not found: " + key){}
      };
      
      struct UnassignableTypesException : public utils::ICLException{
        UnassignableTypesException(const std::string &tSrc, const std::string &tDst):
        utils::ICLException("Unable to assign "+ tDst+ " = "+ tSrc){}
      };
      
      
      class Data{
        
        DataArray *data;
        
        inline Data(DataArray *data):data(data){}
        
        static void assign(void *src, const std::string &srcType, void *dst, 
                           const std::string &dstType) throw (UnassignableTypesException); 
  
        public:
        
        struct Event{
          Event(const std::string &msg="", void *data=0):message(msg),data(data){}
        Event(const std::string &msg, const utils::Function<void> &cb): message(msg),data(0),cb(cb){}
        Event(const std::string &msg, const utils::Function<void,const std::string&> &cb2): message(msg),data(0),cb2(cb2){}
          std::string message;
          void *data;
          utils::Function<void> cb;
          utils::Function<void,const std::string&> cb2;
        };
        
        friend class DataStore;
        

        template<class T>
        inline void operator=(const T &t) throw (UnassignableTypesException){
          assign(const_cast<void*>(reinterpret_cast<const void*>(&t)),
                 get_type_name<T>(),data->data,data->type);
        }
  

        template<class T>
        inline T as() const throw (UnassignableTypesException){
          T t;
          assign(data->data,data->type,&t,get_type_name<T>());
          return t;
        }
  
        template<class T>
        operator T() const throw (UnassignableTypesException){
          return as<T>();
        }
  
        const std::string &getTypeID() const { return data->type; }
        
  
        void render() throw (UnassignableTypesException){ 
          *this = Event("render"); 
        }
  
        void link(void *data) throw (UnassignableTypesException){ 
          *this = Event("link", data); 
        }
        
        void install(void *data){
          *this  = Event("install",data);
        }
        
        void install(utils::Function<void,const MouseEvent &> f);
  
        // installs a global function (should be implicit)
        //void install(void (*f)(const MouseEvent &)){
        //  install(function(f));
        //}
        
        void registerCallback(const utils::Function<void> &cb){
          *this = Event("register",cb);
        }
  
        void registerCallback(const utils::Function<void,const std::string&> &cb){
          *this = Event("register-complex",cb);
        }
        
        void enable(){
          *this = Event("enable");
        }
        
        void disable(){
          *this = Event("disable");
        }
      };
      
  

      Data operator[](const std::string &key) throw (KeyNotFoundException);
      
      

      template<class T>
      std::vector<T> collect(const std::vector<std::string> &keys){
        std::vector<T> v(keys.size());
        for(unsigned int i=0;i<keys.size();++i) v[i] = operator[](keys[i]);
        return v;
      }
  
      static void list_possible_assignments(const std::string &srcType, const std::string &dstType);
      
      struct Assign{
        std::string srcType,dstType,srcRTTI,dstRTTI;
        Assign(const std::string &srcType, const std::string &dstType, 
               const std::string &srcRTTI, const std::string &dstRTTI):
        srcType(srcType),dstType(dstType),srcRTTI(srcRTTI),dstRTTI(dstRTTI){}

        virtual bool operator()(void *src, void *dst){ return false; }
      };
  

      private:
      
      static void register_assignment_rule(Assign *assign);
      
      public:
      

      template<class SRC, class DST>
      static inline void register_assignment_rule(const std::string &srcTypeName,
                                                  const std::string &dstTypeName,
                                                  utils::Function<void,const SRC&,DST&> assign){
        struct TypeDependentAssign : public Assign{
          utils::Function<void,const SRC&,DST&> assign;
          TypeDependentAssign(const std::string &srcTypeName, const std::string &dstTypeName,
                              utils::Function<void,const SRC&,DST&> assign):
          Assign(srcTypeName, dstType, get_type_name<SRC>(), get_type_name<DST>()),assign(assign){}
          
          virtual bool operator()(void *src, void *dst){ 
            assign( *(const SRC*)src, *(DST*)dst );
            return true;
          }
        };
        register_assignment_rule(new TypeDependentAssign(srcTypeName,dstTypeName,assign));
      }


      template<class SRC, class DST>
      static inline void register_trivial_assignment_rule(const std::string &srcTypeName,
                                                          const std::string &dstTypeName){
        struct TypeDependentTrivialAssign : public Assign{
          TypeDependentTrivialAssign(const std::string &srcTypeName, const std::string &dstTypeName):
          Assign(srcTypeName, dstTypeName, get_type_name<SRC>(),  get_type_name<DST>()){}
          
          virtual bool operator()(void *src, void *dst){ 
            *(DST*)dst = *(const SRC*)src;
            return true;
          }
        };
        register_assignment_rule(new TypeDependentTrivialAssign(srcTypeName,dstTypeName));
      }
      
    };
  } // namespace qt
}