/home/tobi/workspace/solarpowerlog/src/Inverters/interfaces/InverterBase.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 (IValue.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 INVERTERBASE_H_
#define INVERTERBASE_H_

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

#include <string>
#include <map>

#include "Connections/interfaces/IConnect.h"
#include "interfaces/CCapability.h"
#include "patterns/ICommandTarget.h"
#include "configuration/ILogger.h"

class ICapaIterator;

using namespace std;

#define CONFIG_TWEAK_CONNECTION_TIMEOUT "option_connectiontimeout"
#define CONFIG_TWEAK_CONNECTION_TIMEOUT_DEFAULT (15000)

// TODO: This class renamed, as it also fits for the "Filters" (Data source, data computing/enhancing, ...)
// Inverters will be only a special interface, derived from this base class
class IInverterBase: public ICommandTarget
{

public:
     friend class ICapaIterator;

     IInverterBase(const string &name, const string & configurationpath,
               const string & role);

     virtual ~IInverterBase();

     virtual const std::string& GetName(void) const;

     // TODO Move to c++ file
     virtual CCapability *GetConcreteCapability(const string &identifier);

     virtual ICapaIterator* GetCapaNewIterator();

     virtual bool CheckConfig() = 0;

     virtual const std::string& GetConfigurationPath() const
     {
          return configurationpath;
     }

     virtual IConnect * getConnection(void) const {
          return connection;
     }

protected:

#warning TODO: Make this interface obsolete.
     virtual void AddCapability(const string &id, CCapability* capa);

protected:
     virtual void AddCapability(CCapability* capa)
     {
          AddCapability(capa->getDescription(), capa);
     }

     virtual map<string, CCapability*>::iterator
     GetCapabilityIterator(void);

     virtual map<string, CCapability*>::iterator GetCapabilityLastIterator(void);

     std::string configurationpath;
     std::string name;

     // Class for handling the connectivity.
     // Is a strategy design pattern interface. So different ways of connection can be handled by the same interface
     // (In other words: Our inverter does need nor want to know, if it is RS485 or TCP/IP, or even, both.)
     // NOTE: The Connection is to be made by a factory!
     // NOTE2: Beware: Connections can die any time! Make sure to handle this.
     IConnect *connection;

protected:

     // This maps contains all the Caps by the Inverter.
     // Caps implements the Subject in the Observer-Pattern.
     // This keeps all informed!
     // Class for handling capabilities.
     // (Inverters can add capabilities at runtime, also can enhancement filters.
     // (A Capabilites bundles on discret feature, reading of a inverter,
     // like also current readings and so on...

     map<string, CCapability*> CapabilityMap;

     ILogger logger;
};

#endif /* INVERTERBASE_H_ */

// debug code to keep...

// Dumping the map.
//        map<string, CCapability*>::iterator it1 = CapabilityMap.begin();
//        cerr << "DUMP Capabilites: " << this->GetName() <<  endl;
//        for (int i=0; it1 != CapabilityMap.end(); it1++,i++)
//        {
//             cerr << i << " " << (*it1).first << endl;
//        }