/home/tobi/workspace/solarpowerlog/src/configuration/CConfigHelper.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 solarpowerlog
 Copyright (C) 2009  Tobias Frost

 This file is part of solarpowerlog.

 Solarpowerlog is free software; However, it is dual-licenced
 as described in the file "COPYING".

 For this file (CConfigHelper.h), the license terms are:

 You can redistribute it and/or  modify it under the terms of the GNU Lesser
 General Public License (LGPL) as published by the Free Software Foundation;
 either version 3 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Library General Public
 License along with this proramm; if not, see
 <http://www.gnu.org/licenses/>.
 ----------------------------------------------------------------------------
 */

#ifndef CCONFIGHELPER_H_
#define CCONFIGHELPER_H_

#include <string>
#include <libconfig.h++>

#include "configuration/Registry.h"

using namespace std;

class CConfigHelper
{
public:
     /***/
     CConfigHelper( const string& configurationpath );
     virtual ~CConfigHelper();

// FIXME Document me
     bool CheckConfig( const string &setting, libconfig::Setting::Type type,
          bool optional = false, bool printerr = true );

     template<class T>

     bool GetConfig( string const &setting, T &store, T defvalue )
     {
          libconfig::Setting & set
               = Registry::Instance().GetSettingsForObject(cfgpath);

          if (!set.lookupValue(setting, store)) {
               store = defvalue;
               return false;
          }
          return true;
     }

     template<class T>
     bool GetConfig( char const *setting, T &store, const T defvalue )
     {
          string s = setting;
          return GetConfig(s, store, defvalue);
     }

     template<class T>
     bool GetConfig( const string &setting, T &store )
     {
          libconfig::Setting & set
               = Registry::Instance().GetSettingsForObject(cfgpath);

          if (!set.lookupValue(setting, store)) {
               return false;
          }
          return true;
     }

     template<class T>
     bool GetConfig( char const *setting, T &store )
     {
          string s = setting;
          return GetConfig(s, store);
     }

     template<class T>
     bool GetConfigArray( const string& setting, int index, T &store )
     {
          libconfig::Setting & set
               = Registry::Instance().GetSettingsForObject(cfgpath);

          try {
               store = set[setting][index];
               return true;
          } catch (libconfig::SettingNotFoundException e) {
               return false;
          } catch (libconfig::SettingTypeException e) {
               // TODO: Assert here?
               return false;
          }
     }


     bool GetConfigArray( const string& setting, int index, string &store )
     {
          libconfig::Setting & set
               = Registry::Instance().GetSettingsForObject(cfgpath);

          try {
               store = (const char *) set[setting][index];
               return true;
          } catch (libconfig::SettingNotFoundException e) {
               return false;
          } catch (libconfig::SettingTypeException e) {
               // TODO: Assert here?
               return false;
          }
     }

     // this ugly helper is for the CHTHML Writer -- we are having there
     // a list which embeddes a array. The entries are anonymous, that is without
     // a destinctive name.
     // I currently wonder how a bettter access function should look like ;-O)
     // TODO make this more elegant and reusable...
     //
     // so, well, this function looks up an entry in the embedded array,
     // with param i giving the row, index the column.
template<class T>
     bool GetConfigArray( const int i, int index, T &store )
     {
          libconfig::Setting & set
               = Registry::Instance().GetSettingsForObject(cfgpath);

          try {
               store = (const char *) set[i][index];
               return true;
          } catch (libconfig::SettingNotFoundException e) {
               return false;
          } catch (libconfig::SettingTypeException e) {
               // TODO: Assert here?
               return false;
          }
     }

bool GetConfigArray( const int i, int index, string &store )
{
     libconfig::Setting & set
          = Registry::Instance().GetSettingsForObject(cfgpath);

     try {
          store = (const char *) set[i][index];
          return true;
     } catch (libconfig::SettingNotFoundException e) {
          return false;
     } catch (libconfig::SettingTypeException e) {
          // TODO: Assert here?
          return false;
     }
}


private:
     string cfgpath;

};

#endif /* CCONFIGHELPER_H_ */