io.h

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah, Weill Cornell Medical College

 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 3 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, see <http://www.gnu.org/licenses/>.

*/

#ifndef IO_H
#define IO_H

#include <list>
#include <mutex.h>
#include <settings.h>
#include <string>
#include <vector>


namespace IO
{

typedef unsigned long flags_t;

static const flags_t INPUT = 0x1;
static const flags_t OUTPUT = 0x2;

typedef struct
{
 std::string name;
 std::string description;
 flags_t flags;
} channel_t;

class Block;

class Connector : public virtual Settings::Object
{

 friend class Block;

public:

 static Connector *getInstance(void);

 void foreachBlock(void (*callback)(Block *,void *),void *param);

 void foreachConnection(void (*callback)(Block *,size_t,Block *,size_t,void *),void *param);

 void connect(IO::Block *outputBlock,size_t outputChannel,IO::Block *inputBlock,size_t inputChannel);
 void disconnect(IO::Block *outputBlock,size_t outputChannel,IO::Block *inputBlock,size_t inputChannel);

 bool connected(IO::Block *outputBlock,size_t outputChannel,IO::Block *inputBlock,size_t inputChannel);

private:

 // Who uses this??
 //void doDeferred(const Settings::Object::State &);
 //void doSave(Settings::Object::State &) const;

 /*****************************************************************
 * The constructor, destructor, and assignment operator are made *
 * private to control instantiation of the class. *
 *****************************************************************/

 Connector(void) : mutex(Mutex::RECURSIVE) {};
 ~Connector(void) {};
 Connector(const Connector &) {};
 Connector &operator=(const Connector &)
 {
 return *getInstance();
 };

 static Connector *instance;

 void insertBlock(Block *);
 void removeBlock(Block *);

 Mutex mutex;
 std::list<Block *> blockList;

}; // class Connector

class Block : public virtual Settings::Object
{

 friend class Connector;

public:

 Block(std::string name,channel_t *channels,size_t size);
 virtual ~Block(void);

 std::string getName(void) const
 {
 return name;
 };
 virtual size_t getCount(flags_t type) const;
 virtual std::string getName(flags_t type,size_t index) const;
 virtual std::string getDescription(flags_t type,size_t index) const;
 virtual double getValue(flags_t type,size_t index) const;

 double input(size_t index) const;
 double output(size_t index) const;

protected:

 double &output(size_t index);

private:

 struct input_t;
 struct output_t;

 /***************************************************************
 * Calls to connect and disconnect are designed such that they *
 * don't have to synchronize with input() and output(). That *
 * is to say the lists are always in a readable state. But *
 * this means there can only be one writer, so calls to *
 * connect() and disconnect() are serialized with mutex. *
 ***************************************************************/

 static Mutex mutex;
 static void connect(Block *,size_t,Block *,size_t);
 static void disconnect(Block *,size_t,Block *,size_t);

 /*************************************************************
 * yogi exists because "double &output(size_t n)" has to *
 * return a reference to something if n >= outputs.size(). *
 *************************************************************/

 static double yogi;

 struct link_t
 {
 Block *block;
 size_t channel;
 };

 struct input_t
 {
 std::string name;
 std::string description;
 std::list<struct link_t> links;
 };

 struct output_t
 {
 std::string name;
 std::string description;
 double value;
 std::list<struct link_t> links;
 };

 std::string name;
 std::vector<struct input_t> inputs;
 std::vector<struct output_t> outputs;

}; // class Block


} // namespace IO

#endif // IO_H