ioconnections.h

Go to the documentation of this file.

/*******************************************************************\

                   SESAME project software license

              Copyright (C) 2002 University of Amsterdam

    This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
        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 General Public License for more details.

  You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
                           02111-1307, USA.

      For information regarding the SESAME software project see
              http://sesamesim.sourceforge.net or email
                    jcofflan@users.sourceforge.net

\*******************************************************************/

#ifndef IOCONNECTIONS_INCLUDE_ONCE
#define IOCONNECTIONS_INCLUDE_ONCE

#include "io.h"
#include "string.h"
#include "cppprocessloader.h"
#include "datablockclass.h"

#include <BasicUtils/BasicException.h>
#include <BasicUtils/BasicString.h>

#include <unistd.h>

template<class T>
class Reader : public In<T> {
  CPPProcessLoader *loader;
  int portId;
  const char *name;

 public:
  Reader(CPPProcessLoader *loader, const char *name);
  virtual ~Reader() {}

  virtual void read(T& value);
  virtual void read(T* p, unsigned int n);
  //virtual FifoBase* selector() const;
};

template<class T> inline
Reader<T>::Reader(CPPProcessLoader *loader, const char *name) :
  loader(loader), name(name) {

  portId = loader->findPort(name)->getID();
}

template<class T> inline
void Reader<T>::read(T &value) {
  ASSERT_OR_THROW("NULL this pointer!", this);
  //cout << "Reading " << name << " " << portId << endl;
  DataBlockClass *data = loader->read(portId);
  ASSERT_OR_THROW("NULL data block", data);

  if (data->getSize() != sizeof(T))
    THROW(string("Read datablock size ") + BasicString(data->getSize()) +
          " does not match expected size " + BasicString(sizeof(T)) + ".");

  value = *((T *)data->getData());
  delete ((T *)data->getData()); // Data
  delete data->detatch(); // DataBlock
  delete data;  // DataBlockClass
}

template<class T> inline
void Reader<T>::read(T *p, unsigned int n) {
//  THROW("Not implemented!");

        for (unsigned int i=0; i<n; i++)
                read(p[i]);
}

// *** Writer ***
template<class T>
class Writer : public Out<T> {
  CPPProcessLoader *loader;
  int portId;
  const char *name;

 public:
  Writer(CPPProcessLoader *loader, const char *name);
  virtual ~Writer() {}

  virtual void write(const T& value);
  virtual void write(const T* p, unsigned int n);
  //virtual FifoBase* selector() const;
};

template<class T> inline
Writer<T>::Writer(CPPProcessLoader *loader, const char *name) :
  loader(loader), name(name) {

  portId = loader->findPort(name)->getID();
}

template<class T> inline
void Writer<T>::write(const T &value) {
  //cout << "Writing to " << loader->getName() << '.' << name << endl;

  DataBlock *dataBlock = new DataBlock;

  T *copy = new T(value);
  dataBlock->size = sizeof(T);
  dataBlock->data = (char *)copy;
  DataBlockClass *data = new DataBlockClass(dataBlock);
  loader->write(portId, data);
}

template<class T> inline
void Writer<T>::write(const T *p, unsigned int n) {
//  THROW("Not implemented!");

        for (unsigned int i=0; i<n; i++)
                write(p[i]);
}
#endif // IOCONNECTIONS_INCLUDE_ONCE

---