interfaces.h

Go to the documentation of this file.

/***************************************************************************
                          interfaces.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 SIMTHETIC_INTERFACES_HEADER
#define SIMTHETIC_INTERFACES_HEADER

#include <iostream>
#include <string>
#include <algorithm>
#include <typeinfo>

#include <simthetic/exceptions.h>
#include <simthetic/misc.h>
#include <simthetic/signals.h>


// Needed for windows DLLs
#ifndef DLLIMPORT
#  ifdef __declspec
#    if BUILDING_SIMTHETICBASE_DLL
#      define DLLIMPORT __declspec (dllexport)
#    else     /* Not BUILDING_LAPACK_DLL */
#      define DLLIMPORT __declspec (dllimport)
#    endif    /* Not BUILDING_SIMTHETICBASE_DLL */
#  else
#    define DLLIMPORT
#  endif    /* __declspec */
#endif  /* DLLIMPORT */


namespace simth
{


class Device;


class DLLIMPORT DataInterface
{
    Device* const device_;
    int ID_;
  protected:

    int ID() const {return ID_;}
    Device* const device() const {return device_;}

  public:

    DataInterface(Device* const device, int ID)
        : device_(device), ID_(ID) {};

    virtual ~DataInterface() {};

    static const size_t undefinedLength;
};


class DLLIMPORT InputInterface : public DataInterface
{
  public:

    InputInterface(Device* const dev, int ID);

    virtual ~InputInterface();

    virtual void reset() = 0;

    virtual void acceptNewData(size_t newElements) = 0;

    virtual size_t sequenceLength() const = 0;

    virtual void setSequenceLength(size_t newLen) = 0;

    virtual bool isFilled() const = 0;

    bool isConnected() const {return isConnected_;}

    virtual void acceptConnection();

    virtual void flushProcessedSequence() = 0;

    virtual void releaseProcessedSequence() = 0;

    virtual void processFinished() = 0;

    //virtual size_t currentBufferSize() const = 0;
  private:

    bool isConnected_;



};


template<class T>
class DLLIMPORT InputInterfaceT : public InputInterface
{

  public:
    InputInterfaceT(Device* const dev, int ID,
                    size_t sequenceLength = undefinedLength,
                    const typename T::value_type&
                    default_val = typename T::value_type() );

    InputInterfaceT(Device* const dev, int ID,
                    const typename T::value_type& default_val);

    virtual ~InputInterfaceT();

    T* externSequence(size_t size, size_t capacity);

    T* internSequence();

    virtual void reset();

    virtual void acceptNewData(size_t size);

    virtual size_t sequenceLength() const;

    virtual void setSequenceLength(size_t newLen);

    virtual bool isFilled() const;

    virtual void flushProcessedSequence();

    virtual void releaseProcessedSequence();

    virtual void processFinished();

  protected:
    void incrementRefCount();
    void decrementRefCount();

    size_t storedElements() const {return storedElements_;}
    //size_t currentBufferSize() const {return seqBuffer->size();}

  private:
    typedef typename T::storage_type buffer_type;
    typedef typename T::access_type access_type;

    // Note: This IS different from the external input/output sequence
    // type.  In fact, this is the actual buffer which holds a
    // container with data. On the contrary, the external input/output
    // sequences are shallow copies/pointers to this very
    // buffer. Since February 27, 2003, both are actually different
    // types.

    buffer_type* seqBuffer;



    /* Attributes of the signal class. -- now to be found in the
       seqBuffer sequence.
    */
    //typename T::attributes_type attributes;

    access_type* inputSubSeq;

    access_type* outputSubSeq;

    size_t storedElements_;

    size_t sequenceLength_;

    size_t refCount;

    bool waitingForProcess;

    void invariante() const;

};




class OutputInterface : public DataInterface
{

  public:
    OutputInterface(Device* const dev, int ID)
        : DataInterface(dev,ID) {};

    virtual ~OutputInterface() {};

    virtual void connect(InputInterface* interfacePtr) = 0;

    virtual void reset() = 0;

    virtual size_t sequenceCapacity() const = 0;

    virtual size_t sequenceLength() const = 0;

    virtual void setSequenceCapacity(size_t size) = 0;
    virtual void setSequenceLength(size_t size) = 0;

    virtual bool isConnected() const = 0;

    virtual void flushProcessedSequences() = 0;

    virtual void processFinished() = 0;

  protected:
    static std::string wrongConnectionMsg(const std::type_info& output_if,
                                          const std::type_info& input_if);

};

template<class T>
class OutputInterfaceT : public OutputInterface
{
  private:

    size_t sequenceCapacity_;
    size_t sequenceLength_;

    typedef InputInterfaceT<T> interf_type;

    interf_type* connectedInterface;
    T* currentOutputSequence;

    std::vector<interf_type*> multipleConnectedInterfaces;

    bool isMultipleConnected_;
  protected:
    bool isMultipleConnected() const {return isMultipleConnected_;}
  public:

    OutputInterfaceT(Device* const dev, int ID);

    virtual size_t sequenceCapacity() const {return sequenceCapacity_;}
    virtual size_t sequenceLength() const {return sequenceLength_;}

    virtual void setSequenceCapacity(size_t size);
    virtual void setSequenceLength(size_t size);

    T* const internSequence();

    virtual void connect(InputInterface* interfacePtr);

    virtual void reset();

    /*Returns true if the input interface is connected with another device*/
    virtual bool isConnected() const {return connectedInterface != NULL;}

    virtual void flushProcessedSequences();

    virtual void processFinished();

};

} // namespace


#endif

---