devicesystemintf.h

Go to the documentation of this file.

/***************************************************************************
                          devicesystemintf.h  -  description
                             -------------------
    begin                : Mon Nov 17 2003
    copyright            : (C) 2003 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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 Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef DEVICE_SYSTEM_INTF_HEADER
#define DEVICE_SYSTEM_INTF_HEADER



#include <string>
#include <map>
#include <iostream>

#include <simthetic/misc.h> // required for DEBUG


namespace{
  //For internal use:
  class ParameterWrapper;

}


namespace simth
{


class Device;
class ControlInterface;
class name_conflict;
class no_such_parameter;
class type_error;


class DeviceSystemIntf 
{
  public:

    enum process_signal {
       READY_TO_PROCESS,
       /* Queues a device for refreshing. */
       // REFRESH,
       STOP_ITERATION, 
       STOP_SIMULATION_PREMATURE
    };

    DeviceSystemIntf();
    
    virtual ~DeviceSystemIntf();

    virtual void connectInterface(ControlInterface* interface, const std::string& varName)=0;

    virtual Device* device(int deviceNr) = 0;

    virtual const Device* device(int deviceNr) const = 0;

    virtual void acceptSignal(Device* dev, process_signal sig) = 0;

    template<class T>
    void writeParameter(const std::string& parameterName, const T& value) throw (simth::name_conflict);

    template<class T>
    T readParameter(const std::string& parameterName) const throw (simth::no_such_parameter, simth::type_error);

    virtual void warningMessage(const std::string& warningMess,int deviceNr) const = 0;

 protected:

    void printParameterList(std::ostream &os) const;


 private:

    typedef std::map<std::string,ParameterWrapper*>::const_iterator const_map_iter;
    typedef std::map<std::string,ParameterWrapper*>::iterator map_iter;
    std::map<std::string,ParameterWrapper*> parameterMap;


};

}









//
// Implementation details that have to be 
// declared/defined here
//



namespace{

class ParameterWrapper;

std::ostream& operator<<(std::ostream &os, const ParameterWrapper& pW);


class ParameterWrapper
{
    friend std::ostream& operator<<(std::ostream &os, const ParameterWrapper& pW);

  protected:
    virtual void printParameter(std::ostream& os) const = 0;
  public:
    ParameterWrapper() {};
    virtual ~ParameterWrapper() {};
};

template<class T>
class ParameterWrapperT : public ParameterWrapper
{
  private:
    T parameter_;
  protected:
    virtual void printParameter(std::ostream& os) const;

  public:
    ParameterWrapperT(const T& parameter__);

    T parameter() const {return parameter_;}
};

template<class T>
inline ParameterWrapperT<T>::ParameterWrapperT(const T& parameter__)
    : parameter_(parameter__) { }

template<class T>
inline
void ParameterWrapperT<T>::printParameter(std::ostream& os) const
{
  os<<parameter();
}

} // namespace 

namespace simth {

template<class T>
inline void DeviceSystemIntf::writeParameter(const std::string& parameterName, const T& value)
throw (simth::name_conflict)
{
  //test if a parameter with that name already exists:
  const_map_iter i = parameterMap.find(parameterName);
  if(i != parameterMap.end()) {
    ParameterWrapper* pw = i->second;
    ParameterWrapperT<T>* pwt = dynamic_cast<ParameterWrapperT<T>*>(pw);
    if(pwt != NULL) {
      if (pwt->parameter() == value) {
        // value would be unchanged anyway
        return;
      }
    }
    else {
      if(DEBUG)
        throw simth::name_conflict("DeviceSystemIntf::writeParameter: "
                                   "While trying to insert the parameter "
                                   "with the name '"+parameterName+
                                   "' to the global parameter list, "
                                   "a name conflict occurs: a parameter "
                                   "with that name already exists");
      else
        std::cout << "DeviceSystemIntf::writeParameter: Warning: "
        "While trying to insert the parameter with the name '"
        +parameterName+"' to the global "
        "parameter list, a name conflict occurs: a parameter with "
        "that name already exists" << std::endl;
    }
  }

  ParameterWrapper* pw = new ParameterWrapperT<T>(value);
  parameterMap[parameterName] = pw;
}

template<class T>
inline T DeviceSystemIntf::readParameter(const std::string& parameterName) const
throw (simth::no_such_parameter, simth::type_error)
{
  const_map_iter i = parameterMap.find(parameterName);
  if(i != parameterMap.end()) {
    ParameterWrapper* pw = i->second;
    ParameterWrapperT<T>* pwt = dynamic_cast<ParameterWrapperT<T>*>(pw);
    if(pwt == NULL) {
      throw simth::type_error("While trying to read the parameter value '"+parameterName+"' from the global parameter list a type error"
                              "occured: the stored type with that name and the type you asked for are different.");
    }
    return pwt->parameter();
  }
  else {
    throw simth::no_such_parameter("Could not find '"+parameterName+"' in the global parameter list. Hint: use "
                                   "DeviceSystemIntf::writeParameter() to insert parameters to that list.");
  }
}


} // namespace simth



#endif

---