ConfigFile.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/ConfigFile.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.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/StringUtils.h> 
#include <ICLUtils/Exception.h>
#include <ICLUtils/Lockable.h>
#include <ICLUtils/SmartPtr.h>
#include <map>
#include <typeinfo>

namespace pugi{
  class xml_document;
}
namespace icl{
  namespace utils{
    struct XMLDocumentDelOp{ static void delete_func(pugi::xml_document *h); };


    class ConfigFile : public Lockable{
  
      public:
      friend class ConfigFileGUI;
      
      struct EntryNotFoundException : public ICLException{
        EntryNotFoundException(const std::string &entryName):
        ICLException("Entry " + entryName+" could not be found!"){}
        virtual ~EntryNotFoundException() throw(){}
      };
      
      struct InvalidTypeException : public ICLException{
        InvalidTypeException(const std::string &entryName, const std::string &typeName):
        ICLException("Invalid type " + typeName + " (entry " + entryName + ")"){};
        virtual ~InvalidTypeException() throw() {}
      };
  
      struct UnregisteredTypeException : public ICLException{
        UnregisteredTypeException(const std::string &rttiID):
        ICLException("type with RTTI ID " + rttiID + " is not registered"){}
        ~UnregisteredTypeException() throw(){}
      };
  
      private:
      
      struct Maps{
        std::map<std::string,std::string> typeMap;
        
        std::map<std::string,std::string> typeMapReverse;
      };
      
      static Maps *getMapsInstance();
      
      static Maps &getMapsInstanceRef() { return *getMapsInstance(); }
#if 0
      static std::map<std::string,std::string> s_typeMap;
      static std::map<std::string,std::string> s_typeMapReverse;
#endif

      template<class T>
      static const std::string &get_type_name() throw (UnregisteredTypeException){
        static const std::string &rttiID = get_rtti_type_id<T>();
        if(!type_registered_by_rtti(rttiID)) throw UnregisteredTypeException(rttiID);
        static const std::string &name = getMapsInstanceRef().typeMap[rttiID];
        return name;
      }
  
      template<class T>
      static inline const std::string &get_rtti_type_id(){
        static std::string NAME = typeid(T).name();
        return NAME;
      }
  
      template<class T>
      inline bool check_type(const std::string &id) const throw (EntryNotFoundException,UnregisteredTypeException){
        return check_type_internal(id,get_rtti_type_id<T>());
      }
  
      bool check_type_internal(const std::string &id, const std::string &rttiTypeID) const 
      throw (EntryNotFoundException,UnregisteredTypeException);
  
      static bool type_registered_by_rtti(const std::string &rttiID){
        Maps &maps = getMapsInstanceRef();
        return (maps.typeMap.find(rttiID) != maps.typeMap.end());
      }
      
      public:
  
#define REGISTER_CONFIG_FILE_TYPE(T) ::icl::utils::ConfigFile::register_type<T>(#T)

  

      template<class T>
      static void register_type(const std::string &id){
        Maps &maps = getMapsInstanceRef();
        std::string rtti = get_rtti_type_id<T>();
        maps.typeMap[rtti] = id;
        maps.typeMapReverse[id] = rtti;
#if 0
        s_typeMap[get_rtti_type_id<T>()] = id;
        s_typeMapReverse[id] = get_rtti_type_id<T>();
#endif
      }
      

      ConfigFile();
      

      ConfigFile(const std::string &filename) throw(FileNotFoundException,InvalidFileFormatException,UnregisteredTypeException);
      

      ConfigFile(pugi::xml_document *handle) throw (UnregisteredTypeException);


      ConfigFile(std::istream &stream) throw(FileNotFoundException,InvalidFileFormatException,UnregisteredTypeException);
      

      void load(const std::string &filename) throw(FileNotFoundException,InvalidFileFormatException,UnregisteredTypeException);
  
      void save(const std::string &filename) const;
      
      void setPrefix(const std::string &defaultPrefix) const;
      
      const std::string &getPrefix() const;
  

      class Data{
        std::string id; 
        ConfigFile *cf; 
        
        Data(const std::string &id, ConfigFile &cf);
        public:
        
        friend class ConfigFile;
        

        template<class T> 
        operator T() const throw (InvalidTypeException,EntryNotFoundException){
          return cf->get<T>(id);
        }
        

        template<class T>
        T as() const throw (InvalidTypeException,EntryNotFoundException){
          return cf->get<T>(id);
        }
  

        Data &operator=(const Data &d){
          cf = d.cf;
          id = d.id;
          return *this;
        }
        

        template<class T>
        Data &operator=(const T &t) throw (UnregisteredTypeException,InvalidTypeException,EntryNotFoundException){
          cf->set(id,t);
          return *this;
        }
      };
  
     
      /* This function can be used for reading as well as for writing ConfigFile entries
         the returned utitlity structure of type Data defers creation of a new
         ConfigFile entry until actually a value is assigned to it.
      **/
      Data operator [](const std::string &id);
      

      const Data operator[](const std::string &id) const throw (EntryNotFoundException);
        

      std::vector<Data> find(const std::string &regex);
      

      const std::vector<Data> find(const std::string &regex) const{
        return const_cast<ConfigFile*>(this)->find(regex);
      }
      

      template<class T>
      void set(const std::string &id, const T &val) throw (UnregisteredTypeException){
        set_internal(id,str(val),get_rtti_type_id<T>());
      }
      

      template<class T>
      inline T get(const std::string &idIn) const throw (EntryNotFoundException,InvalidTypeException,UnregisteredTypeException){
        if(!contains(idIn)) throw EntryNotFoundException(m_sDefaultPrefix+idIn);
        if(!check_type<T>(idIn)) throw InvalidTypeException(m_sDefaultPrefix+idIn,get_type_name<T>());
        return parse<T>(m_entries.find(m_sDefaultPrefix+idIn)->second.value);
      }
      

      template<class T>
      inline T get(const std::string &idIn,const T &def) const throw (InvalidTypeException,UnregisteredTypeException){
        if(!contains(idIn)) return def;
        if(!check_type<T>(idIn)) throw InvalidTypeException(m_sDefaultPrefix+idIn,get_type_name<T>());
        return parse<T>(m_entries.find(m_sDefaultPrefix+idIn)->second.value);
      }
  
      static void loadConfig(const std::string &filename);
  
      static void loadConfig(const ConfigFile &configFile);
      
      static const ConfigFile &getConfig(){ return s_oConfig; }
  
      template<class T>
      static inline T sget(const std::string &id) throw (EntryNotFoundException,InvalidTypeException){
        return getConfig().get<T>(id);
      }
      
      template<class T>
      static inline T sget(const std::string &id,const T &def) throw (InvalidTypeException){
        return getConfig().get<T>(id,def);
      }
      
      void listContents() const;
  
      bool contains(const std::string &id) const;
  

      struct KeyRestriction{
        inline KeyRestriction():
          hasRange(false),hasValues(false){}
        inline KeyRestriction(double min, double max):
          min(min),max(max),hasRange(true),hasValues(false){}
        inline KeyRestriction(const std::string &values):
          values(values),hasRange(false),hasValues(true){}
        std::string toString() const;
  
        double min,max;
        std::string values;
  
        bool hasRange;
        bool hasValues;
      };
      

      void setRestriction(const std::string &id, const KeyRestriction &r) throw (EntryNotFoundException);
  

      const KeyRestriction *getRestriction(const std::string &id) const throw (EntryNotFoundException);
  
      struct Entry{
        std::string id;           
        std::string value;        
        std::string rttiType;     
        SmartPtr<KeyRestriction> restr;  
  
        const std::string &getTypeName() const { return getMapsInstanceRef().typeMap[rttiType]; }
  
        std::string getRelID() const {
          const std::string &pfx = parent->getPrefix();
          if(!pfx.length()) return id;
          else return id.substr(pfx.length());
        }
        ConfigFile *parent; // parent ConfigFile (used to obtain current prefix)
      };
  
      typedef std::map<std::string,Entry>::const_iterator const_iterator;
      
      const_iterator begin() const{ return m_entries.begin(); }
      
      const_iterator end() const{ return m_entries.end(); }
      
      const std::vector<const Entry*> getEntryList(bool relToPrefix=false) const{
        std::vector<const Entry*> v;
        for(const_iterator it =begin();it != end(); ++it){
          v.push_back(&it->second);
        }
        return v;
      }
      
      void clear();
      

      const pugi::xml_document *getHandle() const { return m_doc.get(); }
      
      private:
      
      void load_internal();
      
      Entry &get_entry_internal(const std::string &id) throw (EntryNotFoundException);
  
      const Entry &get_entry_internal(const std::string &id) const throw (EntryNotFoundException);
  
      void set_internal(const std::string &id, const std::string &val, const std::string &type) throw (UnregisteredTypeException);
  
      static void add_to_doc(pugi::xml_document &h,const std::string &id,const std::string &type, 
                             const std::string &value,const KeyRestriction *restr=0);
       
      mutable SmartPtrBase<pugi::xml_document,XMLDocumentDelOp> m_doc;
      
      static ConfigFile s_oConfig;
      
  
      mutable std::string m_sDefaultPrefix;
  
  
      std::map<std::string,Entry> m_entries;
  
      friend std::ostream &operator<<(std::ostream&,const ConfigFile&);
    };
    
    
    std::ostream &operator<<(std::ostream &s, const ConfigFile &cf);
  
    template<> inline ConfigFile::Data &ConfigFile::Data::operator=(char * const &t) 
    throw (UnregisteredTypeException,InvalidTypeException,EntryNotFoundException){
      return ConfigFile::Data::operator=(std::string(t));
    }
    template<> inline ConfigFile::Data &ConfigFile::Data::operator=(const char * const &t) 
    throw (UnregisteredTypeException,InvalidTypeException,EntryNotFoundException){
      return ConfigFile::Data::operator=(std::string(t));
    }
  } // namespace utils
}