model.hpp

Go to the documentation of this file.

#ifndef CORAL_MODEL_HPP
#define CORAL_MODEL_HPP

#include <cstdint>
#include <iterator>
#include <limits>
#include <map>
#include <string>
#include <vector>

#include <boost/range/adaptor/map.hpp>
#include <boost/variant.hpp>

#include <coral/config.h>


namespace coral
{
namespace model
{


typedef std::int32_t StepID;


const StepID INVALID_STEP_ID = -1;


typedef double TimePoint;


const TimePoint ETERNITY = std::numeric_limits<TimePoint>::infinity();


typedef double TimeDuration;


typedef std::uint16_t SlaveID;


const SlaveID INVALID_SLAVE_ID = 0;


typedef std::uint32_t VariableID;


enum DataType
{
    REAL_DATATYPE       = 1,
    INTEGER_DATATYPE    = 1 << 1,
    BOOLEAN_DATATYPE    = 1 << 2,
    STRING_DATATYPE     = 1 << 3,
};


enum Causality
{
    PARAMETER_CAUSALITY             = 1,
    CALCULATED_PARAMETER_CAUSALITY  = 1 << 1,
    INPUT_CAUSALITY                 = 1 << 2,
    OUTPUT_CAUSALITY                = 1 << 3,
    LOCAL_CAUSALITY                 = 1 << 4,
};


enum Variability
{
    CONSTANT_VARIABILITY    = 1,
    FIXED_VARIABILITY       = 1 << 1,
    TUNABLE_VARIABILITY     = 1 << 2,
    DISCRETE_VARIABILITY    = 1 << 3,
    CONTINUOUS_VARIABILITY  = 1 << 4,
};


class VariableDescription
{
public:
    VariableDescription(
        coral::model::VariableID id,
        const std::string& name,
        coral::model::DataType dataType,
        coral::model::Causality causality,
        coral::model::Variability variability);

    coral::model::VariableID ID() const;

    const std::string& Name() const;

    coral::model::DataType DataType() const;

    coral::model::Causality Causality() const;

    coral::model::Variability Variability() const;

private:
    VariableID m_id;
    std::string m_name;
    coral::model::DataType m_dataType;
    coral::model::Causality m_causality;
    coral::model::Variability m_variability;
};


class SlaveTypeDescription
{
    typedef std::map<VariableID, VariableDescription> VariablesMap;
public:
    typedef boost::select_second_const_range<VariablesMap>
        ConstVariablesRange;

    // Construction/destruction
    SlaveTypeDescription() CORAL_NOEXCEPT;

    template<typename VariableDescriptionRange>
    SlaveTypeDescription(
        const std::string& name,
        const std::string& uuid,
        const std::string& description,
        const std::string& author,
        const std::string& version,
        const VariableDescriptionRange& variables);

    ~SlaveTypeDescription() = default;

    // Copy
    SlaveTypeDescription(const SlaveTypeDescription&) = default;
    SlaveTypeDescription& operator=(const SlaveTypeDescription&) = default;

    // Move
    CORAL_DEFINE_DEFAULT_MOVE(SlaveTypeDescription,
        m_name, m_uuid, m_description, m_author, m_version, m_variables)

    const std::string& Name() const;

    const std::string& UUID() const;

    const std::string& Description() const;

    const std::string& Author() const;

    const std::string& Version() const;

    ConstVariablesRange Variables() const;

    const VariableDescription& Variable(VariableID id) const;

private:
    std::string m_name;
    std::string m_uuid;
    std::string m_description;
    std::string m_author;
    std::string m_version;
    VariablesMap m_variables;
};


class SlaveDescription
{
public:
    // Construction/destruction
    explicit SlaveDescription(
        SlaveID id = INVALID_SLAVE_ID,
        const std::string& name = std::string(),
        const SlaveTypeDescription& typeDescription = SlaveTypeDescription());

    ~SlaveDescription() = default;

    // Copy
    SlaveDescription(const SlaveDescription&) = default;
    SlaveDescription& operator=(const SlaveDescription&) = default;

    // Move
    CORAL_DEFINE_DEFAULT_MOVE(SlaveDescription, m_id, m_name, m_typeDescription)

    
    SlaveID ID() const;

    void SetID(SlaveID value);

    const std::string& Name() const;

    void SetName(const std::string& value);

    const SlaveTypeDescription& TypeDescription() const;

    void SetTypeDescription(const SlaveTypeDescription& value);

private:
    SlaveID m_id;
    std::string m_name;
    SlaveTypeDescription m_typeDescription;
};


typedef boost::variant<double, int, bool, std::string> ScalarValue;


DataType DataTypeOf(const ScalarValue& v);


class Variable
{
public:
    explicit Variable(SlaveID slave = INVALID_SLAVE_ID, VariableID id = 0)
        : m_slave(slave), m_id(id) { }

    coral::model::SlaveID Slave() const CORAL_NOEXCEPT { return m_slave; }
    coral::model::VariableID ID() const CORAL_NOEXCEPT { return m_id; }
    bool Empty() const CORAL_NOEXCEPT { return m_slave == INVALID_SLAVE_ID; }

private:
    coral::model::SlaveID m_slave;
    coral::model::VariableID m_id;
};


bool operator==(const Variable& a, const Variable& b);

bool operator!=(const Variable& a, const Variable& b);


class VariableSetting
{
public:
    VariableSetting(
        VariableID variable,
        const ScalarValue& value);

    VariableSetting(
        VariableID inputVar,
        const coral::model::Variable& outputVar);

    VariableSetting(
        VariableID inputVar,
        const ScalarValue& value,
        const coral::model::Variable& outputVar);

    VariableID Variable() const CORAL_NOEXCEPT;

    bool HasValue() const CORAL_NOEXCEPT;

    const ScalarValue& Value() const;

    bool IsConnected() const CORAL_NOEXCEPT;

    const coral::model::Variable& ConnectedOutput() const;

private:
    VariableID m_variable;
    bool m_hasValue;
    ScalarValue m_value;
    coral::model::Variable m_connectedOutput;
};


bool IsValidSlaveName(const std::string& s);


// =============================================================================
// Function template definitions
// =============================================================================

template<typename VariableDescriptionRange>
SlaveTypeDescription::SlaveTypeDescription(
    const std::string& name,
    const std::string& uuid,
    const std::string& description,
    const std::string& author,
    const std::string& version,
    const VariableDescriptionRange& variables)
    : m_name(name),
      m_uuid(uuid),
      m_description(description),
      m_author(author),
      m_version(version)
{
    for (const auto& v : variables) {
        m_variables.insert(std::make_pair(v.ID(), v));
    }
}


}}      // namespace
#endif  // header guard