port.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_SYSTEMS_PORT_H_
#define SYDEVS_SYSTEMS_PORT_H_

#include <sydevs/systems/node_interface.h>

namespace sydevs {
namespace systems {


template<data_mode dmode, data_goal dgoal, typename T>
class port_base
{
public:
    port_base(const port_base&)            = delete;   
    port_base& operator=(const port_base&) = delete;   
    port_base(port_base&&)                 = default;  
    port_base& operator=(port_base&&)      = default;  
    virtual ~port_base()                   = default;  

    const std::string& port_name() const;  

    int64 port_index() const;  
    int64 node_index() const;  

    const node_interface& external_interface() const;  

protected:
    port_base(const std::string& port_name, int64 port_index, node_interface& external_interface);

private: 
    const std::string port_name_;
    const int64 port_index_;
    node_interface& external_interface_;
};


template<data_mode dmode, data_goal dgoal, typename T>
class port : public port_base<dmode, dgoal, T>
{
};


template<typename T>
class port<flow, input, T> : public port_base<flow, input, T>
{
public:
    port(const std::string& port_name, const node_interface& external_interface);

    port(port&&)            = default;   
    port& operator=(port&&) = default;   
    ~port()                 = default;   

    const T& value() const;  

    void print_on_use(bool flag = true) const;  
};


template<typename T>
class port<message, input, T> : public port_base<message, input, T>
{
public:
    port(const std::string& port_name, const node_interface& external_interface);

    port(port&&)            = default;   
    port& operator=(port&&) = default;   
    ~port()                 = default;   

    bool received() const;   
    const T& value() const;  

    void print_on_use(bool flag = true) const;  
};


template<typename T>
class port<message, output, T> : public port_base<message, output, T>
{
public:
    port(const std::string& port_name, const node_interface& external_interface);

    port(port&&)            = default;   
    port& operator=(port&&) = default;   
    ~port()                 = default;   

    void send(const T& val);  

    void print_on_use(bool flag = true) const;  
};


template<typename T>
class port<flow, output, T> : public port_base<flow, output, T>
{
public:
    port(const std::string& port_name, const node_interface& external_interface);

    port(port&&)            = default;   
    port& operator=(port&&) = default;   
    ~port()                 = default;   

    void assign(const T& val);  

    void print_on_use(bool flag = true) const;  
};


template<data_mode dmode, data_goal dgoal, typename T>
const std::string& port_base<dmode, dgoal, T>::port_name() const
{
    return port_name_;
}

    
template<data_mode dmode, data_goal dgoal, typename T>
int64 port_base<dmode, dgoal, T>::port_index() const
{
    return port_index_;
}


template<data_mode dmode, data_goal dgoal, typename T>
int64 port_base<dmode, dgoal, T>::node_index() const
{
    return external_interface_.node_index();
}


template<data_mode dmode, data_goal dgoal, typename T>
const node_interface& port_base<dmode, dgoal, T>::external_interface() const
{
    return external_interface_;
}


template<data_mode dmode, data_goal dgoal, typename T>
port_base<dmode, dgoal, T>::port_base(const std::string& port_name, int64 port_index, node_interface& external_interface)
    : port_name_(port_name)
    , port_index_(port_index)
    , external_interface_(external_interface)
{
    if (!qualified_type<T>::valid) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Invalid data type for port (" + this->port_name() + ") " +
                               "of node (" + full_node_name + ")");
    }
}


template<typename T>
port<flow, input, T>::port(const std::string& port_name, const node_interface& external_interface)
    : port_base<flow, input, T>(
        port_name,
        const_cast<node_interface&>(external_interface).add_flow_input_port(port_name), 
        const_cast<node_interface&>(external_interface))
{
}


template<typename T>
const T& port<flow, input, T>::value() const
{
    if (!this->external_interface().active()) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to get value on flow input port (" + this->port_name() + ") " +
                               "of inactive node (" + full_node_name + ")");
    }
    const auto& val = const_cast<node_interface&>(this->external_interface()).flow_input_port_value(this->port_index());
    return const_cast<const T&>(val.template dereference<T>());
}


template<typename T>
void port<flow, input, T>::print_on_use(bool flag) const
{
    auto tostring_func = flag ? tostring_converter<T>() : nullptr;
    const_cast<node_interface&>(this->external_interface()).set_flow_input_printable(this->port_index(), tostring_func);
}

    
template<typename T>
port<message, input, T>::port(const std::string& port_name, const node_interface& external_interface)
    : port_base<message, input, T>(
        port_name,
        const_cast<node_interface&>(external_interface).add_message_input_port(port_name),
        const_cast<node_interface&>(external_interface))
{
}


template<typename T>
bool port<message, input, T>::received() const
{
    if (!this->external_interface().active()) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to check message input port (" + this->port_name() + ") " +
                               "of inactive node (" + full_node_name + ")");
    }
    if (this->external_interface().dmode() != message || this->external_interface().dgoal() != input) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to check message input port (" + this->port_name() + ") " +
                               "of node (" + full_node_name + ") outside of unplanned event");
    }
    return const_cast<node_interface&>(this->external_interface()).message_input_port_index() == this->port_index();
}


template<typename T>
const T& port<message, input, T>::value() const
{
    if (!this->external_interface().active()) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to get value on message input port (" + this->port_name() + ") " +
                               "of inactive node (" + full_node_name + ")");
    }
    if (this->external_interface().dmode() != message || this->external_interface().dgoal() != input) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to get value on message input port (" + this->port_name() + ") " +
                               "of node (" + full_node_name + ") outside of unplanned event");
    }
    const auto& val = const_cast<node_interface&>(this->external_interface()).message_input_port_value(this->port_index());
    return const_cast<const T&>(val.template dereference<T>());
}


template<typename T>
void port<message, input, T>::print_on_use(bool flag) const
{
    auto tostring_func = flag ? tostring_converter<T>() : nullptr;
    const_cast<node_interface&>(this->external_interface()).set_message_input_printable(this->port_index(), tostring_func);
}

    
template<typename T>
port<message, output, T>::port(const std::string& port_name, const node_interface& external_interface)
    : port_base<message, output, T>(
        port_name,
        const_cast<node_interface&>(external_interface).add_message_output_port(port_name),
        const_cast<node_interface&>(external_interface))
{
}


template<typename T>
void port<message, output, T>::send(const T& val)
{
    if (!this->external_interface().active()) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to send value on message output port (" + this->port_name() + ") " +
                               "of inactive node (" + full_node_name + ")");
    }
    if (this->external_interface().dmode() != message || this->external_interface().dgoal() != output) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to send value on message output port (" + this->port_name() + ") " +
                               "of node (" + full_node_name + ") outside of planned event");
    }
    const_cast<node_interface&>(this->external_interface()).append_message_output(this->port_index(), qualified_type<T>::copy(val));
}


template<typename T>
void port<message, output, T>::print_on_use(bool flag) const
{
    auto tostring_func = flag ? tostring_converter<T>() : nullptr;
    const_cast<node_interface&>(this->external_interface()).set_message_output_printable(this->port_index(), tostring_func);
}

    
template<typename T>
port<flow, output, T>::port(const std::string& port_name, const node_interface& external_interface)
    : port_base<flow, output, T>(
        port_name,
        const_cast<node_interface&>(external_interface).add_flow_output_port(port_name),
        const_cast<node_interface&>(external_interface))
{
}


template<typename T>
void port<flow, output, T>::assign(const T& val)
{
    if (!this->external_interface().active()) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to assign value on flow output port (" + this->port_name() + ") " +
                               "of inactive node (" + full_node_name + ")");
    }
    if (this->external_interface().dmode() != flow) {
        const auto& full_node_name = const_cast<node_interface&>(this->external_interface()).full_name();
        throw std::logic_error("Attempt to assign value on flow output port (" + this->port_name() + ") " +
                               "of node (" + full_node_name + ") outside of initialization or finalization event");
    }
    const_cast<node_interface&>(this->external_interface()).assign_flow_output(this->port_index(), qualified_type<T>::copy(val));
}


template<typename T>
void port<flow, output, T>::print_on_use(bool flag) const
{
    auto tostring_func = flag ? tostring_converter<T>() : nullptr;
    const_cast<node_interface&>(this->external_interface()).set_flow_output_printable(this->port_index(), tostring_func);
}

    
}  // namespace
}  // namespace

#endif