node_interface.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_SYSTEMS_NODE_INTERFACE_H_
#define SYDEVS_SYSTEMS_NODE_INTERFACE_H_
 
#include <sydevs/systems/node_context.h>
#include <sydevs/core/qualified_type.h>
#include <sydevs/systems/data_mode.h>
#include <sydevs/systems/data_goal.h>
 
namespace sydevs {
namespace systems {
 
class system_node;
 
 
class node_interface
{
public:
    node_interface(const std::string& node_name, system_node* node_ptr, const node_context& external_context);
 
    node_interface(const node_interface&)            = delete;   
    node_interface& operator=(const node_interface&) = delete;   
    node_interface(node_interface&&)                 = delete;   
    node_interface& operator=(node_interface&&)      = delete;   
    virtual ~node_interface()                        = default;  
 
    const std::string& node_name();
    const std::string& full_name();
    int64 node_index();
 
    node_context& external_context();
 
    int64 add_flow_input_port(const std::string& port_name);
    int64 flow_input_port_count();
    const std::string& flow_input_port_name(int64 port_index);
    const pointer& flow_input_port_value(int64 port_index);
    void clear_flow_inputs();
    void assign_flow_input(int64 port_index, const pointer& val);
    tostring_function flow_input_tostring_func(int64 port_index);
    void set_flow_input_printable(int64 port_index, tostring_function tostring_func);
 
    int64 add_message_input_port(const std::string& port_name);
    int64 message_input_port_count();
    const std::string& message_input_port_name(int64 port_index);
    const pointer& message_input_port_value(int64 port_index);
    int64 message_input_port_index();
    void clear_message_input();
    void set_message_input(int64 port_index, const pointer& val);
    tostring_function message_input_tostring_func(int64 port_index);
    void set_message_input_printable(int64 port_index, tostring_function tostring_func);
 
    int64 add_message_output_port(const std::string& port_name);
    int64 message_output_port_count();
    const std::string& message_output_port_name(int64 port_index);
    int64 message_output_list_size();
    int64 message_output_index(int64 list_index);
    const pointer& message_output_value(int64 list_index);
    void clear_message_outputs();
    void append_message_output(int64 port_index, const pointer& val);
    tostring_function message_output_tostring_func(int64 port_index);
    void set_message_output_printable(int64 port_index, tostring_function tostring_func);
 
    int64 add_flow_output_port(const std::string& port_name);
    int64 flow_output_port_count();
    const std::string& flow_output_port_name(int64 port_index);
    const pointer& flow_output_port_value(int64 port_index);
    void clear_flow_outputs();
    void assign_flow_output(int64 port_index, const pointer& val);
    tostring_function flow_output_tostring_func(int64 port_index);
    void set_flow_output_printable(int64 port_index, tostring_function tostring_func);
 
    void activate(data_mode dmode, data_goal dgoal);
    void deactivate();
 
    bool active() const;
    data_mode dmode() const;
    data_goal dgoal() const;
 
    int64 missing_flow_input();
    int64 missing_flow_output();
 
    void print_port_value(const std::string& port_name, const std::string& val_string);
    void print_flow_input(int64 port_index);
    void print_message_input(int64 port_index);
    void print_message_output(int64 list_index, int64 port_index);
    void print_flow_output(int64 port_index);
 
    void print_command_text(const std::string& command, const std::string& text);
 
    bool print_on_event_flag();
    void print_on_event(bool flag = true);
    void print_event(const std::string& text);
 
    bool print_on_elapsed_duration_flag();
    void print_on_elapsed_duration(bool flag);
    void print_elapsed_duration(duration elapsed_dt);
 
    bool print_on_planned_duration_flag();
    void print_on_planned_duration(bool flag);
    void print_planned_duration(duration planned_dt);
 
private:
    void print(const std::string& text);
 
    std::string node_name_;
    std::string full_name_;
    int64 node_index_;
 
    node_context& external_context_;
 
    std::vector<std::string> flow_input_port_names_;
    std::vector<tostring_function> flow_input_port_tostring_funcs_;
    std::vector<pointer> flow_input_port_vals_;
 
    std::vector<std::string> message_input_port_names_;
    std::vector<tostring_function> message_input_port_tostring_funcs_;
    std::vector<pointer> message_input_port_vals_;
    int64 message_input_port_index_;
 
    std::vector<std::string> message_output_port_names_;
    std::vector<tostring_function> message_output_port_tostring_funcs_;
    std::vector<int64> message_output_indices_;
    std::vector<pointer> message_output_vals_;
 
    std::vector<std::string> flow_output_port_names_;
    std::vector<tostring_function> flow_output_port_tostring_funcs_;
    std::vector<pointer> flow_output_port_vals_;
 
    bool active_;
    data_mode dmode_;
    data_goal dgoal_;
 
    bool print_on_event_;
    bool print_on_elapsed_duration_;
    bool print_on_planned_duration_;
};
 
 
inline const std::string& node_interface::node_name()
{
    return node_name_;
}
 
 
inline const std::string& node_interface::full_name()
{
    return full_name_;
}
 
    
inline int64 node_interface::node_index()
{
    return node_index_;
}
 
 
inline node_context& node_interface::external_context()
{
    return external_context_;
}
 
 
inline void node_interface::activate(data_mode dmode, data_goal dgoal)
{
    active_ = true;
    dmode_ = dmode;
    dgoal_ = dgoal;
}
 
 
inline void node_interface::deactivate()
{
    active_ = false;
}
 
 
inline bool node_interface::active() const
{
    return active_;
}
 
 
inline data_mode node_interface::dmode() const
{
    return dmode_;
}
 
 
inline data_goal node_interface::dgoal() const
{
    return dgoal_;
}
 
 
}  // namespace
}  // namespace
 
#endif