basicdevice.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          basicdevice.h  -  description
                             -------------------
    begin                : Wed May 8 2002
    copyright            : (C) 2002 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 BASIC_DEVICE_HEADER
#define BASIC_DEVICE_HEADER

#include <simthetic/exceptions.h>
#include <simthetic/controlinterface.h>
#include <simthetic/signals.h>
#include <simthetic/interfaces.h>
#include <simthetic/propertylist.h>
#include <simthetic/phbib.h>


namespace simth
{

class DeviceSystemIntf;
class LoopControl;
class ControlInterface;
class InputInterface;
class OutputInterface;


class Device
{
  private:
    friend class CompatibleDevice;

    simth::checkedVector<InputInterface*> inputInterfaces;
    simth::checkedVector<OutputInterface*> outputInterfaces;

    simth::checkedVector<ControlInterface*> controlInterfaces;

    bool lockedInputLengths_;
    bool lockedOutputLengths_;

    bool isInterrupted_;

    clock_t startClock;
    bool isStopWatchRunning;
    clock_t simulationClocks;

    bool lockedInputLengths() const {return lockedInputLengths_;}
    void lockInputLengths() {lockedInputLengths_ = true;}
    void unlockInputLengths() {lockedInputLengths_ = false;}

    bool lockedOutputLengths() const {return lockedOutputLengths_; }
    void lockOutputLengths() {lockedOutputLengths_ = true;}
    void unlockOutputLengths() {lockedOutputLengths_ = false;}

    int ID_;
    DeviceSystemIntf* system_;

    PropertyList properties;

    Device(const PropertyList& pl);

    void processStarted();

    void processFinished();

  protected:


    template<class T>
    void setProperty(const std::string& name, const T& value);

    DeviceSystemIntf* systemPtr() {return system_;}

    template<class T>
    size_t insertInputInterface(int number = 1,
                                const typename T::value_type&
                                default_val = typename T::value_type() );

    virtual InputInterface* inputInterface(int interfaceID);

    virtual const InputInterface* inputInterface(int interfaceID) const;


    bool isInputInterface(int interfaceID) const;

    bool isInputInterfaceConnected(int interfaceID) const;

    bool isInputSequence(int interfaceID) const;

    template<class T>
    T* getInputSequence(int interfaceID);



    template<class T>
    size_t insertOutputInterface(int number = 1);

    virtual OutputInterface* outputInterface(int interfaceID);

    virtual const OutputInterface* outputInterface(int interfaceID) const;


    bool isOutputInterface(int interfaceID) const;

    bool isOutputInterfaceConnected(int interfaceID) const;

    template<class T>
    T* getOutputSequence(int interfaceID);


    virtual void updateInputLengths() = 0;

    virtual void updateOutputLengths() = 0;


    void flushProcessedSequences();

    void flushProcessedInputSequences();


    void flushProcessedOutputSequences();

    void flushProcessedInputSequence(int interface);

    void flushProcessedOutputSequence(int interface);

    void releaseProcessedInputSequence(int interface);


    template<class D>
    size_t insertControlInterface(D* dev, void (D::* helpFuncPtr)());

    template<class T, class D>
    size_t insertControlInterface(D* dev, void (D::* helpFuncPtr)(T));



    template<class D>
    size_t insertAndConnectControlInterface(D* dev, void (D::* helpFuncPtr)(),
                                            const std::string& globalName);

    template<class T, class D>
    size_t insertAndConnectControlInterface(D* dev, void (D::* helpFuncPtr)(T),
                                            const std::string& globalName);


    bool isControlInterface(int interfaceID) const;


    virtual ControlInterface* controlInterface(int interfaceNr);


    /* Sends refresh signal to the interface:
       -- this was never used and therefore removed on 2004-10-19.
    */
    //void sendRefreshSignal();
    void sendReadyToProcessSignal();
    void sendStopIterationSignal();
    void sendStopSimulationPrematureSignal();

    void interrupt();
    bool isInterrupted() const {return isInterrupted_;}


    void startStopWatch();

    void stopStopWatch();



  public:


    Device(int deviceID, DeviceSystemIntf* system,
           const PropertyList& pl);

    virtual ~Device();


    virtual int ID() const {return ID_;}

    template<class T>
    const T& getProperty(const std::string &name) const;

    bool hasProperty(const std::string& name) const;

    bool propertyIsSet(const std::string& name) const;

    virtual void print(std::ostream &os) const;


    void connect(int fromInterfaceID, Device* toDev, int toInterfaceID);

    void connectControlInterface(int interfaceNr, const std::string& globalName);

    InputInterface* const acceptConnection(int interfaceID);

    virtual void startOfSimulation() {};

    virtual void endOfSimulation() {};



    virtual void refresh() {};

    void invokeProcess();

    virtual void process() = 0;

    virtual void acceptNewData(int interfaceID);


    void resetDevice();

    void resetInterfaces();

    virtual void reset() {};

    void deInterrupt() {isInterrupted_ = false;}



    void setInputLength(size_t newLength,int interfaceID, bool enableUpdate = true);

    void setInputLength(size_t newLength, bool enableUpdate = true);

    size_t inputLength(int interfaceID) const;

    size_t inputLength( ) const;

    bool isInputLengthUndefined(int interfaceID) const;


    void setOutputLength(size_t newLength, int interfaceID, bool enableUpdate = true);

    void setOutputLength(size_t newLength, bool enableUpdate = true);

    size_t outputLength(int interfaceID) const;

    size_t outputLength( ) const;

    bool isOutputLengthUndefined(int interfaceID) const;

    void reserveOutputLength(size_t newCapacity, int interfaceID);

    void reserveOutputLength(size_t newCapacity);

    size_t outputCapacity(int interfaceID) const;
    size_t outputCapacity( ) const;

};




class CompatibleDevice : public Device
{

  public:

    CompatibleDevice(const PropertyList& pl = PropertyList()) : Device(pl) {};

    void setID(int ID);

    void setSystemPtr(DeviceSystemIntf* systemPtr);

};



template<class T>
inline T* Device::getInputSequence(int interfaceID)
{
   InputInterface* iface_ptr = inputInterface(interfaceID);
   InputInterfaceT<T>* helpPtr = dynamic_cast<InputInterfaceT<T>*>(iface_ptr);

   if(helpPtr == NULL) {
      throw std::runtime_error(
     "Device::getInputSequence<T>(): "
     "input interface "+simth::i2string(interfaceID)
     + " of Device "+simth::i2string(ID())
     + " has wrong type: Expected \""
     + simth::demangle(typeid(InputInterfaceT<T>).name()) 
     + "\" but the interface has type \"" 
     + (iface_ptr ? simth::demangle(typeid(*iface_ptr).name()) :
        simth::demangle(typeid(iface_ptr).name()))
     + "\"");
   }
   if(!helpPtr->isConnected()) {
      throw std::runtime_error("Device::getInputSequence(int interfaceID) : "
                               "input interface "+simth::i2string(interfaceID)+
                               " of Device "+simth::i2string(ID())+" is not connected");
   }
   return helpPtr->internSequence();
}





template<class T>
inline T* Device::getOutputSequence(int interfaceID)
{
  OutputInterfaceT<T>* helpPtr = dynamic_cast<OutputInterfaceT<T>*>(outputInterface(interfaceID));
  if(SECURITY) {
    if(helpPtr == NULL) {
      throw std::runtime_error("Device::getOutputSequence(int interfaceID) : "
                               " output interface "+simth::i2string(interfaceID)+
                               " of Device "+simth::i2string(ID())+" has wrong type");
    }
    if(!helpPtr->isConnected()){
       throw std::runtime_error("Device::getOutputSequence(int interfaceID) : "
                               " output interface "+simth::i2string(interfaceID)+
                               " of Device "+simth::i2string(ID())+" is not connected.");
    } 
  }
  return helpPtr->internSequence();
}


template<class T>
inline size_t Device::insertInputInterface(int number,
    const typename T::value_type&
    default_val)
{
  size_t id = inputInterfaces.size();
  for(int i=0; i< number; ++i) {
    InputInterfaceT<T>* newInterface =
      new InputInterfaceT<T>(this, id, default_val);
    inputInterfaces.push_back(newInterface);
    ++id;
  }
  return id;  // Returns the last index plus one, i.e. the *number* of
  // interfaces. The index starts by zero.
}

template<class T>
inline size_t Device::insertOutputInterface(int number)
{
  size_t id = outputInterfaces.size();
  for(int i=0; i< number; ++i) {
    OutputInterfaceT<T>* newInterface = new OutputInterfaceT<T>(this, id);
    outputInterfaces.push_back(newInterface);
    ++id;
  }
  return id;  // Returns the last index plus one, i.e. the *number* of
  // interfaces. The index starts by zero.
}

template<class D>
inline size_t
Device::insertControlInterface(D* dev, void (D::* helpFuncPtr)())
{
  ControlInterfaceVoidD<D>* newVar = new ControlInterfaceVoidD<D>(dev, helpFuncPtr);
  controlInterfaces.push_back(newVar);
  return controlInterfaces.size();
}

template<class T, class D>
inline size_t
Device::insertControlInterface(D* dev, void (D::* helpFuncPtr)(T))
{
  ControlInterfaceTD<T,D>* newVar = new ControlInterfaceTD<T,D>(dev, helpFuncPtr);
  controlInterfaces.push_back(newVar);
  return controlInterfaces.size();
}

template<class D>
inline size_t
Device::insertAndConnectControlInterface(D* dev, void (D::* helpFuncPtr)(),
    const std::string& globalName)
{
  size_t size_ = insertControlInterface<D>(dev,helpFuncPtr);
  connectControlInterface(size_-1,globalName);
  return size_;
}

template<class T, class D>
inline size_t
Device::insertAndConnectControlInterface(D* dev, void (D::* helpFuncPtr)(T),
    const std::string& globalName)
{
  size_t size_ = insertControlInterface<T,D>(dev,helpFuncPtr);
  connectControlInterface(size_-1,globalName);
  return size_;
}

// These must be here because they are template functions...
template<class T>
const T& Device::getProperty(const std::string &name) const
{
  try {
    return properties.PropertyList::getProperty<T>(name);
  }
  catch (std::runtime_error &err) {
    throw std::runtime_error(std::string(err.what()) + " in device "
                             +simth::i2string(ID()));
  }
}

// These must be here because they are template functions...
template<class T>
void Device::setProperty(const std::string& name, const T& value)
{
  try {
    properties.setProperty(name, value);
  }
  catch (std::runtime_error &err) {
    throw std::runtime_error(std::string(err.what()) + " in device "
                             +simth::i2string(ID()));
  }
}

}

#endif

---