interfaces_impl.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   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 INTERFACES_IMPL_H
#define INTERFACES_IMPL_H


#include <cassert>
#include <iostream>

#include <simthetic/interfaces.h>
#include <simthetic/basicdevice.h>
#include <simthetic/phbib.h>

namespace simth
{

template<class T>
InputInterfaceT<T>::InputInterfaceT(Device* const dev, 
                    int ID, size_t sequenceLength,
                    const typename T::value_type& default_val)
   : InputInterface(dev,ID)
   , seqBuffer(new buffer_type(0,default_val))
   , inputSubSeq(new access_type(seqBuffer->begin(),
                 seqBuffer->begin(),
                 *seqBuffer))
   , outputSubSeq(new access_type(seqBuffer->begin(),
                  seqBuffer->begin(),
                  *seqBuffer))
   , storedElements_(0)
   , sequenceLength_(sequenceLength)
   , refCount(0)
   , waitingForProcess(false)
{
   invariante();
}

template<class T>
InputInterfaceT<T>::InputInterfaceT(Device* const dev,
                                    int ID,
                                    const typename T::value_type&
                                    default_val)
   : InputInterface(dev,ID)
   , seqBuffer(new buffer_type(0, default_val))
   , inputSubSeq(new access_type(seqBuffer->begin(),
                 seqBuffer->begin(),
                 *seqBuffer))
   , outputSubSeq(new access_type(seqBuffer->begin(),
                  seqBuffer->begin(),
                  *seqBuffer))
   , storedElements_(0)
   , sequenceLength_(undefinedLength)
   , refCount(0)
   , waitingForProcess(false)
{
   invariante();
}

template<class T>
InputInterfaceT<T>::~InputInterfaceT()
{
   if (std::uncaught_exception()) { //destructor is called while catching an exception.
      //In this case no exception should be thrown, otherwise
      //the program will be terminated (see Stroustrup S.398)
      try {
     delete seqBuffer;
     delete inputSubSeq;
     delete outputSubSeq;
      }
      catch(...) {
     std::cerr<<("InputInterface::~InputInterface() : error 1");
      }
   }
   else {
      try {
     delete seqBuffer;
     delete inputSubSeq;
     delete outputSubSeq;
      }
      catch(...) {
     throw std::logic_error("InputInterface::~InputInterface() : error 2");
      }
   }
}


template<class T>
T* InputInterfaceT<T>::internSequence( )
{
   if (storedElements() < sequenceLength_) {
      throw std::runtime_error(
     "InputInterface::internSequence: "
     "Sequence was not filled completely"
     ", in input iface "+simth::i2string(ID())
     +" of device nr. "+simth::i2string(device()->ID())
     +" (storedElements()== "+simth::i2string(storedElements())
     +" < sequenceLength()== "+simth::i2string(sequenceLength_)+"). "
     "You will most likely encounter this message if you try "
     "to call getInputSequence() without checking first that the "
     "sequence has been filled completely "
     "(by Interface::isFilled() or Device::isInputSequence()).");
   }
   if (refCount != 0) {
      throw std::runtime_error
     ("InputInterface::internSequence: "
      "At least one reference copy exists"
      ", in input iface "+simth::i2string(ID())
      +" of device +"+simth::i2string(device()->ID())+". "
      "You will most likely encounter this message if you try "
      "to call this function (e.g. via Device::getInputSequence()) " 
      "two times consecutively without flushing the interface "
      "(e.g. via Device::flushProcessedSequences()) in between.");
   }
   if (sequenceLength_ == undefinedLength) {
      throw std::runtime_error
     ("InputInterfaceT<T>::internSequence( ) : "
      "sequence length is undefined -> "
      "shouldn't happen since it should already been "
      "set in the function acceptNewData(..)"
      ", in input iface "+simth::i2string(ID())
      +" of device "+simth::i2string(device()->ID()));
   }

   if (sequenceLength_ == 0) {
      // in that case set the sequence length to the number of
      // received and so far not processed elements:
      device()->setInputLength(storedElements(),ID());
   }

   // Take the number of elements specified by sequenceLength():
   outputSubSeq->seek(seqBuffer->begin(),
              seqBuffer->begin() + sequenceLength_);
   incrementRefCount();

   return outputSubSeq;
}



template<class T>
void InputInterfaceT<T>::reset()
{
   seqBuffer->resize(0);
   inputSubSeq->seek(seqBuffer->begin(),seqBuffer->begin());
   outputSubSeq->seek(seqBuffer->begin(),seqBuffer->begin());
   storedElements_ = 0;
   waitingForProcess = false;
   refCount = 0;
}

template<class T>
void InputInterfaceT<T>::acceptNewData(size_t size)
{
   assert(refCount == 1);

   storedElements_ += size;
   invariante();

   decrementRefCount();

   if (!waitingForProcess)
   {
     
      // Sequencelength is so far either undefined or zero.
      if (sequenceLength_ == undefinedLength || sequenceLength_ == 0)
      {
     // Update the sequence length immediately;
     // Device::setInputLength will call setSequenceLength
     // anyway!
     device()->setInputLength(storedElements(), ID());
      }

      // Enough elements have been written into this input
      // interface, so let the device be queued for process.
      if (storedElements() >= sequenceLength_)
      {
     waitingForProcess = true;
     device()->acceptNewData(ID());
      }

   }
}


template<class T>
void InputInterfaceT<T>::invariante() const
{
   if (DEBUG) {
      if (unsigned(storedElements()) > seqBuffer->size()) {
     throw std::logic_error(
        "InputInterfaceT<T>::invariante(): "
        "storedElements() > seqBuffer->size()");
      }
   }
}

template<class T>
void InputInterfaceT<T>::incrementRefCount()
{
   invariante();
   ++refCount;
}

template<class T>
void InputInterfaceT<T>::decrementRefCount()
{
   invariante();
   if (refCount==0) {
      throw simth::connection_error(
     "InputInterfaceT::decrementRefCount(): refcount == 0"
     ", in input iface "+simth::i2string(ID())
     +" of device "
     +simth::i2string(device()->ID()));
   }
   --refCount;
}

template<class T>
inline size_t InputInterfaceT<T>::sequenceLength() const
{
   return sequenceLength_;
}

template<class T>
T* InputInterfaceT<T>::externSequence(size_t subSeqSize, size_t subSeqCapacity)
{
   invariante();

   if (refCount>0) {
      throw std::runtime_error
     ("InputInterface: At least one reference copy exists when "
      "calling externSequence( ) in input iface "+simth::i2string(ID())
      +" of device "+simth::i2string(device()->ID())+". "
      "You will most likely encounter this message if you try "
      "to call this function (e.g. via the function call "
      "Device::getOutputSequence() of the device that is connected "
      "with this input interface) two times consecutively without "
      "flushing the interface (e.g. via the function call "
      "Device::flushProcessedSequences() of the connected "
      "device) in between.");
      /* Until now just one reference copy per time is allowed:
     if (seqBuffer->capacity()-oldSize < newCapacity) {
     throw std::runtime_error("T* InputInterfaceT::buffer(size_t numBits) : resize() not "
     "possible while shallow copies of the buffer exist");
     }
      */
   }
   incrementRefCount();

   // The number of elements that have not yet been processed
   size_t unprocessedSize = storedElements();

   if (unprocessedSize > 0) {
      // If the seqBuffer contains elements that have not yet been
      // processed, lock the attributes
      seqBuffer->lock();
   }
   else {
      // The seqBuffer didn't contain any unprocessed elements, so
      // unlock the attributes.
      seqBuffer->unlock();
   }

   // Resize the storage buffer for the required size.
   // We couldn't call inputSubSeq->resize() here
   // directly, since we could not enlarge a sequence storage via
   // a sequence access class.
   seqBuffer->resize(unprocessedSize + subSeqCapacity);

   // Set the shallow copy to point to the to-be-overwritten part of
   // the storage buffer. It is *vital* to do this here because after a
   // resizing to a bigger size, the inputSubSeq will still point to
   // the old location of the seqBuffer, i.e. memory garbage.
   inputSubSeq->seek(seqBuffer->begin() + unprocessedSize, seqBuffer->end());
   inputSubSeq->resize(subSeqSize);

   return inputSubSeq;
}

template<class T>
void InputInterfaceT<T>::setSequenceLength(size_t newLength)
{
   assert(newLength != undefinedLength);

   sequenceLength_ = newLength;
}



template<class T>
bool InputInterfaceT<T>::isFilled() const
{
   if ( ! isConnected() ) {
      return true;
   }
   if (sequenceLength_ == undefinedLength) {
      return false;
   }
   return (storedElements() >= sequenceLength_);
}

template<class T>
void InputInterfaceT<T>::releaseProcessedSequence()
{
   if (!isConnected())
      return;

   if (refCount>1) {
      // Until now this should happen not at any time, since the
      // input interface class does only allow one shallow copy of
      // the internal buffer per time. If this should be changed
      // somewhere in future, this inquiry could(!) be still useful.
      throw std::runtime_error
     ("InputInterfaceT<T>::releaseProcessedSequence() : "
      "Shallow copies of the buffer exist while calling this function. "
      "Until now Simthetic allows only one shallow copy. This ensures "
      "that the sequence that is accessed by a shallow copy is not "
      "simultaneously modified by another shallow copy.");
   }
   if (refCount==1){
      // one shallow copy (that invokes, at least indirectly, this
      // function) exists
      decrementRefCount();
   }
}

template<class T>
void InputInterfaceT<T>::flushProcessedSequence()
{
   if (!isConnected())
      return;

   // Sanity checking is done in releaseProcessedSequence(), as
   // well as decrementRefCount().
   releaseProcessedSequence();

   assert(refCount == 0);
   if (storedElements() < sequenceLength_) {
      throw std::runtime_error(
     "InputInterfaceT<T>::flushProcessedSequence(): "
     "error 2");
   }

   // Advance the sequence buffer:
   typename T::iterator newBeginIter = seqBuffer->begin()+sequenceLength_;
   std::rotate(seqBuffer->begin(), newBeginIter , seqBuffer->end());
   storedElements_ -= sequenceLength_;
}


template<class T>
void InputInterfaceT<T>::processFinished()
{
   if (!isConnected())
      //do nothing:
      return;

   if (storedElements() >= sequenceLength_) {
      // This could happen if the device has more than two input
      // interfaces and the other input interface has not had enough
      // elements to proceed processing.
      device()->acceptNewData(ID());
   }
   else {
      waitingForProcess = false;
   }
}


// ////////////////////////////////////////////////////////////

template<class T>
OutputInterfaceT<T>::OutputInterfaceT(Device* const dev, int ID)
   : OutputInterface(dev,ID),
     sequenceCapacity_(0),
     sequenceLength_(undefinedLength),
     connectedInterface(NULL),
     currentOutputSequence(NULL),
     multipleConnectedInterfaces(simth::checkedVector<interf_type*>(0))
   , isMultipleConnected_(false) 
{
}


template<class T>
T* const OutputInterfaceT<T>::internSequence()
{
   if (!isConnected()) {
      throw simth::no_connection_error(
     "OutputInterface::internSequence(): "
     "no connection"
     ", in output iface "+simth::i2string(ID())
     +" of device "
     +simth::i2string(device()->ID()));
   }
   if (sequenceLength_ == undefinedLength){
      throw std::runtime_error
     ("OutputInterface::internSequence(): The output length of the "
      "output interface "+simth::i2string(ID())+
      " of device "+simth::i2string(device()->ID())+
      " was not set before calling the function internSequence(). "
      "You will most likely encounter this error messages "
      "if you did not set the output length of that "
      "interface (using the function setOutputLength(length,interfaceNr)) "
      "before accessing the output sequence (using the function "
      "getOutputSequence<T>(interfaceNr)).");
   }

   currentOutputSequence = 
      connectedInterface->externSequence(sequenceLength_,
                     sequenceCapacity_);
   return currentOutputSequence;
}


template<class T>
void OutputInterfaceT<T>::setSequenceCapacity(size_t capacity)
{
   if (sequenceLength_ == undefinedLength) {
      throw std::runtime_error(
     "OutputInterfaceT<T>::setSequenceCapacity: "
     "sequence length is undefined");
   }
   if (capacity <= sequenceLength_) {
      // Nothing happens since the requiredBuffer size is at least
      // the sequence length
      return;
   }
   sequenceCapacity_ = capacity;
}


template<class T>
void OutputInterfaceT<T>::setSequenceLength(size_t newLength)
{
   assert(newLength != undefinedLength);

   // Reset also the sequenceCapacity_ (capacity)
   sequenceCapacity_ = sequenceLength_ = newLength;
}



template<class T>
void OutputInterfaceT<T>::reset()
{
   // Release the pointer. It is up to someone else to inform the
   // input interface, i.e. this is done by the system calling
   // reset for all input and output interfaces.
   currentOutputSequence = NULL;
}


template<class T>
void OutputInterfaceT<T>::flushProcessedSequences()
{
   if (!isConnected())
      return;
   if (currentOutputSequence == NULL) { //device did not use the output
      throw std::runtime_error(
     "OutputInterface::flushProcessedSequences() : "
     "It seems that the function  'flushProcessedSequences()' "
     "in output iface "+simth::i2string(ID())+
     " of device "+simth::i2string(device()->ID())+" has been called "
     "without requesting a sequences from that interface "
     "before. Make sure that getOutputSequence is called "
     "before calling this function.");
   }

   const size_t processedSize = currentOutputSequence->size();

   if (processedSize > sequenceLength_){
      // This is possible if the capacity is set explicitly by
      // setSequenceCapacity()
      if (processedSize > sequenceCapacity()){
     throw std::logic_error
        ("OutputInterfaceT<T>::flushProcessedSequences() : "
         "internal simthetic error: processed size "
         "is larger than the sequence capacity, this should not happen");
      }

      throw std::logic_error
     ("OutputInterfaceT<T>::flushProcessedSequences(): "
      "The output sequence to be flushed is larger than the "
      "set sequence length of that interface. This occurs most "
      "likely if you set a larger output capacity using the "
      "function reserveOutputLength() of the device class, "
      "enlarge the sequence to a size that exceeds the set "
      "output length of that device and then you do not resize "
      "the sequence to the output length before flushing the "
      "sequence. Note: the capacity feature should only be used "
      "to enlarge the output sequence intermediately. If you have "
      "in mind to to get a larger output sequence set the output "
      "sequence to that length rather than enlarging the "
      "sequence capacity.");
   }


   // If the output interface is multiple connected, copy the
   // sequence to the other connected interfaces. This is not
   // really efficient for now, but at least it works correctly.
   if (isMultipleConnected()) {
      assert(!multipleConnectedInterfaces.empty());

      for (size_t i=0; i < multipleConnectedInterfaces.size(); ++i)
      {
     T* helpPtr =  multipleConnectedInterfaces[i]->externSequence(processedSize,processedSize);
     assert(processedSize == helpPtr->size());
     
     for (size_t i = 0; i < processedSize; ++i) {
        (*helpPtr)[i] = (*currentOutputSequence)[i];
     }
      }
   }

   // Signal the arrival of the new data to the connected input
   // interfaces.
   connectedInterface->acceptNewData(processedSize);

   for (size_t i=0; i < multipleConnectedInterfaces.size(); ++i) {
      multipleConnectedInterfaces[i]->acceptNewData(processedSize);
   }

   currentOutputSequence->resize(0);
}

template<class T>
void OutputInterfaceT<T>::processFinished()
{
   if (!isConnected())
      return;

   if (currentOutputSequence != NULL) {
      // Are there still bits which are not flushed?
      size_t processedSize = currentOutputSequence->size();
      if (processedSize != 0) {
     //until now this should not happen:
     throw std::runtime_error
        ("void OutputInterfaceT<T>::processFinished() : "
         "unflushed elements remain in the output "
         "interface "+simth::i2string(ID())+
         " of device "+simth::i2string(device()->ID())+". "
         "Call flushProcessedSequences() in the "
         "process function of that device.");
     //alternative: flushProcessedSequences();
      }
   }
   //else{ //no data was requested from that output interface before -> do nothing!}
}

template<class T>
void OutputInterfaceT<T>::connect(InputInterface* interfacePtr)
{
   assert(interfacePtr);
   if (connectedInterface == NULL) {
      connectedInterface = dynamic_cast<InputInterfaceT<T>* const>(interfacePtr);
      if (connectedInterface == NULL) {
     throw simth::type_mismatch_connection(
        wrongConnectionMsg(typeid(InputInterfaceT<T>),
                   typeid(*interfacePtr)));
      }
   }
   else {
      isMultipleConnected_ = true;
      interf_type* helpPtr = NULL;
      helpPtr = dynamic_cast<InputInterfaceT<T>* const>(interfacePtr);
      if (helpPtr == NULL) {
     throw simth::type_mismatch_connection(
        wrongConnectionMsg(typeid(InputInterfaceT<T>),
                   typeid(*interfacePtr)));
      }
      multipleConnectedInterfaces.insert(multipleConnectedInterfaces.end(), helpPtr);
   }
}

} // namespace simth

#endif // #ifdef INTERFACES_IMPL_H

---