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.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/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 ICLUtils_API XMLDocumentDelOp{ static void delete_func(pugi::xml_document *h); };

    class ICLUtils_API 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() {
        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 {
        return check_type_internal(id,get_rtti_type_id<T>());
      }

      bool check_type_internal(const std::string &id, const std::string &rttiTypeID) const
      ;

      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);


      ConfigFile(pugi::xml_document *handle);


      ConfigFile(std::istream &stream);


      void load(const std::string &filename);

      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 {
          return cf->get<T>(id);
        }


        template<class T>
        T as() const {
          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) {
          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 ;


      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) {
        set_internal(id,str(val),get_rtti_type_id<T>());
      }


      template<class T>
      inline T get(const std::string &idIn) const {
        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 {
        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) {
        return getConfig().get<T>(id);
      }

      template<class T>
      static inline T sget(const std::string &id,const T &def) {
        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):
          hasRange(true),hasValues(false){
            this->min = min;
            this->max = max;
        }
        inline KeyRestriction(const std::string &values):
          values(values),hasRange(false),hasValues(true){}
        ICLUtils_API std::string toString() const;

        double min,max;
        std::string values;

        bool hasRange;
        bool hasValues;
      };


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


      const KeyRestriction *getRestriction(const std::string &id) const ;

      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) ;

      const Entry &get_entry_internal(const std::string &id) const ;

      void set_internal(const std::string &id, const std::string &val, const std::string &type) ;

      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 ICLUtils_API std::ostream &operator<<(std::ostream&, const ConfigFile&);
    };


    ICLUtils_API std::ostream &operator<<(std::ostream &s, const ConfigFile &cf);

    template<> inline ConfigFile::Data &ConfigFile::Data::operator=(char * const &t)
    {
      return ConfigFile::Data::operator=(std::string(t));
    }
    template<> inline ConfigFile::Data &ConfigFile::Data::operator=(const char * const &t)
    {
      return ConfigFile::Data::operator=(std::string(t));
    }
  } // namespace utils
}