io.hpp

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah,
 Will 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 <array>
#include <limits>
#include <string>
#include <vector>


namespace IO
{

constexpr size_t INVALID_BLOCK_ID = std::numeric_limits<size_t>::max();

enum flags_t : size_t
{
 OUTPUT = 0,
 INPUT,
 UNKNOWN
};

typedef struct channel_t
{
 std::string name;
 std::string description;
 IO::flags_t flags = IO::UNKNOWN; // IO::INPUT or IO::OUTPUT
} channel_t;

class Block
{
public:
 Block(std::string blockname,
 const std::vector<channel_t>& channels,
 bool isdependent); // default constructor
 Block(const Block& block) = default; // copy constructor
 Block& operator=(const Block& block) = default; // copy assignment operator
 Block(Block&&) = delete; // move constructor
 Block& operator=(Block&&) = delete; // move assignment operator
 virtual ~Block() = default;

 std::string getName() const { return name; }

 size_t getCount(flags_t type) const;

 std::string getChannelName(IO::flags_t type, size_t index) const;

 std::string getChannelDescription(IO::flags_t type, size_t index) const;

 void writeinput(size_t index, const double& data);

 const double& readPort(IO::flags_t direction, size_t index);

 bool dependent() const { return this->isInputDependent; }

 bool getActive() const { return this->active; }

 void setActive(bool act) { this->active = act; }

 void assignID(size_t block_id) { this->id = block_id; }

 size_t getID() const { return this->id; }

protected:
 double& readinput(size_t index);

 void writeoutput(size_t index, const double& data);

private:
 size_t id = INVALID_BLOCK_ID;
 typedef struct port_t
 {
 double buff_value = 0.0;
 double value = 0.0;
 IO::channel_t channel_info;
 } port_t;
 std::string name;
 bool isInputDependent;
 std::array<std::vector<port_t>, IO::UNKNOWN> ports;
 bool active = false;
}; // class Block

typedef struct endpoint
{
 IO::Block* block = nullptr;
 size_t port = 0;
 IO::flags_t direction = IO::UNKNOWN;
 bool operator==(const endpoint& rhs) const
 {
 return (this->block == rhs.block) && (this->port == rhs.port)
 && (this->direction == rhs.direction);
 }
 bool operator!=(const endpoint& rhs) const { return !operator==(rhs); }
} endpoint;

} // namespace IO

#endif // IO_H