/home/tobi/workspace/solarpowerlog/src/configuration/Registry.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 (Registry), 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 REGISTRY_H_
#define REGISTRY_H_

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <assert.h>
#include <list>
#include <utility>
#include <string>
#include <libconfig.h++>

#include <boost/noncopyable.hpp>
#include "interfaces/CWorkScheduler.h"

#include "configuration/ILogger.h"

class IInverterBase;

using namespace std;

class Registry : boost::noncopyable
{
public:

     friend class CConfigHelper;

     static Registry& Instance()
     {
          static Registry Instance;
          return Instance;
     }

     // C O N F I G U R A T I O N

     inline static libconfig::Config* Configuration()
     {
          return Registry::Instance().Config;
     }

     inline static ILogger & GetMainLogger(void) {
          return Registry::Instance().l;
     };

     bool LoadConfig( std::string name );

     /* NOTE: This is obsolete! Use an Object of CConfigHelper to extract config!
      *
      *  Extract the settings-subset for a specific object,
      * identified by section (like inverters) and name (like inverter_solarmax_1)
      *
      * ex:
      *
      * inverters = (
      *                       { name = "Inverter_1";
      *                         type = "Solarmax_XYZ";
      *                         driver = "Sputnik_TCP";
      *                         # (...)
      *                       },
      *                       { name = "Inverter_2";
      *                         type = "Solarmax_XYZ";
      *                         driver = "Sputnik_TCP";
      *                         # (...)
      *                       }
      *                  );
      *
      * and  GetSettingsForObject("inverters", "Inverter_1") will return the Settings object
      * for the group "inverters.[0]".
      *
      * Please note, that libconfig throws some exceptions: Especially, if the section is not found.
      * This is not handled here, as the Factories should check if the configuration is complete on
      * constructing them. (They also can add their own settings (default values)...
      *
      * [code]
      *
      *   libconfig::Setting &set = Registry::Instance().GetSettingsForObject("inverters", "Inverter_1");
      *   libconfig::Setting &new = set.add("NewPropertyNotSet",libconfig::Setting::TypeString);
      *   new = "New Default Setting";
      *
      * [/code]
      *
      * Snippet to retrieve Settings:
      * [code]
      *        libconfig::Setting &set = Registry::Instance().GetSettingsForObject("inverters", "Inverter_1");
      * [/code]
      *
      * \warning This function is not intended to check if a setting exists!
      */

private:
     libconfig::Setting & GetSettingsForObject( std::string section,
          std::string objname = "" );
public:
     IInverterBase* GetInverter( const string& name ) const;

     void AddInverter( const IInverterBase *inverter );

     static CWorkScheduler *GetMainScheduler( void )
     {
          if(! Registry::Instance().mainscheduler) {
               Registry::Instance().mainscheduler = new CWorkScheduler;
          }
          return Registry::Instance().mainscheduler;
     }

private:
     CWorkScheduler *mainscheduler;

protected:
     Registry();
     virtual ~Registry();

private:
     libconfig::Config *Config;

     // TODO generalize this interface, as we might also store
     // other types of objects here.
     list<IInverterBase*> inverters;

     ILogger l;

};

#endif /* REGISTRY_H_ */