system_node.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_SYSTEMS_SYSTEM_NODE_H_
#define SYDEVS_SYSTEMS_SYSTEM_NODE_H_

#include <sydevs/systems/node_interface.h>
#include <sydevs/systems/port.h>
#include <sydevs/core/timer.h>

namespace sydevs {
namespace systems {


class system_node
{
public:
    class error;

    system_node(const system_node&)            = delete;   
    system_node& operator=(const system_node&) = delete;   
    system_node(system_node&&)                 = delete;   
    system_node& operator=(system_node&&)      = delete;   
    virtual ~system_node()                     = default;  

    const std::string& node_name() const;  
    const std::string& full_name() const;  
    int64 node_index() const;              

    const node_interface& external_interface() const;  

    const timer& event_timer() const;  

    template<typename T>
    void print(const T& X);               
    void print(const char* raw_text);     
    void print(const std::string& text);  

    void print_on_event(bool flag = true) const;  

    void adopt_print_flags(const system_node& node) const;  

    virtual data_mode node_dmode() const = 0;  
    virtual scale time_precision() const = 0;  

    duration process_initialization_event();                
    duration process_unplanned_event(duration elapsed_dt);  
    duration process_planned_event(duration elapsed_dt);    
    void process_finalization_event(duration elapsed_dt);   

protected:
    std::mt19937& rng;  

    system_node(const std::string& node_name, const node_context& external_context);

    node_interface& external_IO() const;  
    timer& ET() const;                    

    duration scale_planned_dt(duration planned_dt) const;

private:
    virtual void adopt_component_print_flags(const system_node& node) const = 0;

    virtual duration handle_initialization_event() = 0;
    virtual duration handle_unplanned_event(duration elapsed_dt) = 0;
    virtual duration handle_planned_event(duration elapsed_dt) = 0;
    virtual void handle_finalization_event(duration elapsed_dt) = 0;

    node_interface external_interface_;
    timer event_timer_;
};



class system_node::error : public std::runtime_error
{
public:
    explicit error(const std::string& what_arg);
    explicit error(const char* what_arg);
};


inline const std::string& system_node::node_name() const
{
    return external_IO().node_name();
}


inline const std::string& system_node::full_name() const
{
    return external_IO().full_name();
}


inline int64 system_node::node_index() const
{
    return external_IO().node_index();
}


inline const node_interface& system_node::external_interface() const
{
    return const_cast<const node_interface&>(external_interface_);
}


inline const timer& system_node::event_timer() const
{
    return event_timer_;
}


template<typename T>
inline void system_node::print(const T& X)
{
    print(tostring(X));
}


inline void system_node::print(const char* raw_text)
{
    print(std::string(raw_text));
}


inline void system_node::print(const std::string& text)
{
    external_interface_.print_command_text("print", text);
}


inline void system_node::print_on_event(bool flag) const
{
    external_IO().print_on_event(flag);
}


inline duration system_node::process_initialization_event()
{
    auto planned_dt = duration();
    try {
        planned_dt = handle_initialization_event();
    }
    catch (error&) {
        if (ET().timing()) {
            ET().stop();
        }
        throw;
    }
    catch (const std::exception& e) {
        if (ET().timing()) {
            ET().stop();
        }
        external_IO().print_command_text("error", e.what());
        throw error("Aborting event in node (" + full_name() + ") due to error (\"" + e.what() + "\")");
    }
    return planned_dt;
}


inline duration system_node::process_unplanned_event(duration elapsed_dt)
{
    auto planned_dt = duration();
    try {
        planned_dt = handle_unplanned_event(elapsed_dt);
    }
    catch (error&) {
        if (ET().timing()) {
            ET().stop();
        }
        throw;
    }
    catch (const std::exception& e) {
        if (ET().timing()) {
            ET().stop();
        }
        external_IO().print_command_text("error", e.what());
        throw error("Aborting event in node (" + full_name() + ") due to error (\"" + e.what() + "\")");
    }
    return planned_dt;
}


inline duration system_node::process_planned_event(duration elapsed_dt)
{
    auto planned_dt = duration();
    try {
        planned_dt = handle_planned_event(elapsed_dt);
    }
    catch (error&) {
        if (ET().timing()) {
            ET().stop();
        }
        throw;
    }
    catch (const std::exception& e) {
        if (ET().timing()) {
            ET().stop();
        }
        external_IO().print_command_text("error", e.what());
        throw error("Aborting event in node (" + full_name() + ") due to error (\"" + e.what() + "\")");
    }
    return planned_dt;
}


inline void system_node::process_finalization_event(duration elapsed_dt)
{
    try {
        handle_finalization_event(elapsed_dt);
    }
    catch (error&) {
        if (ET().timing()) {
            ET().stop();
        }
        throw;
    }
    catch (const std::exception& e) {
        if (ET().timing()) {
            ET().stop();
        }
        external_IO().print_command_text("error", e.what());
        throw error("Aborting event in node (" + full_name() + ") due to error (\"" + e.what() + "\")");
    }
}


inline system_node::system_node(const std::string& node_name, const node_context& external_context)
    : rng(const_cast<node_context&>(external_context).rng())
    , external_interface_(node_name, this, external_context)
    , event_timer_()
{
}


inline node_interface& system_node::external_IO() const
{
    return const_cast<node_interface&>(external_interface_);
}


inline timer& system_node::ET() const
{
    return const_cast<timer&>(event_timer_);
}


inline system_node::error::error(const std::string& what_arg)
    : runtime_error(what_arg)
{
}


inline system_node::error::error(const char* what_arg)
    : runtime_error(what_arg)
{
}


}  // namespace
}  // namespace

#endif