Node.hpp

#pragma once
#include <Dataflow/RaDataflow.hpp>
 
#include <Core/Containers/VariableSet.hpp>
#include <Core/Utils/Index.hpp>
#include <Dataflow/Core/PortFactory.hpp>
#include <Dataflow/Core/PortIn.hpp>
#include <Dataflow/Core/PortOut.hpp>
 
#include <nlohmann/json.hpp>
 
#include <memory>
#include <string>
#include <type_traits> // conditional, is_same
#include <vector>
 
namespace Ra {
namespace Dataflow {
namespace Core {
 
class RA_DATAFLOW_CORE_API Node
{
  public:
    using PortIndex = Ra::Core::Utils::Index;
 
    template <typename Port>
    using PortCollection = std::vector<Port>;
 
    template <typename Port>
    using PortPtr = std::shared_ptr<Port>;
    template <typename Port>
    using PortRawPtr = Port*;
 
    template <typename Type>
    using PortInPtr = PortPtr<PortIn<Type>>;
    template <typename Type>
    using PortInRawPtr = PortIn<Type>*;
 
    template <typename Type>
    using PortOutPtr = PortPtr<PortOut<Type>>;
    template <typename Type>
    using PortOutRawPtr = PortOut<Type>*;
 
    using PortBasePtr        = PortPtr<PortBase>;
    using PortBaseRawPtr     = PortRawPtr<PortBase>;
    using PortBaseCollection = PortCollection<PortBasePtr>;
 
    using PortBaseInPtr        = PortPtr<PortBaseIn>;
    using PortBaseInRawPtr     = PortRawPtr<PortBaseIn>;
    using PortBaseInCollection = PortCollection<PortBaseInPtr>;
 
    using PortBaseOutPtr        = PortPtr<PortBaseOut>;
    using PortBaseOutRawPtr     = PortRawPtr<PortBaseOut>;
    using PortBaseOutCollection = PortCollection<PortBaseOutPtr>;
 
    template <typename Port>
    using IndexAndPort = std::pair<PortIndex, Port>;
 
    template <typename T>
    using ParamHandle = Ra::Core::VariableSet::VariableHandle<T>;
 
    Node()                         = delete;
    Node( const Node& )            = delete;
    Node& operator=( const Node& ) = delete;
 
    virtual ~Node() = default;
 
    bool operator==( const Node& node );
 
 
    virtual void init();
 
    virtual bool compile();
 
    virtual bool execute() = 0;
 
    virtual void destroy();
 
 
    auto port_by_name( const std::string& type, const std::string& name ) const
        -> IndexAndPort<PortBaseRawPtr>;
 
    auto input_by_name( const std::string& name ) const -> IndexAndPort<PortBaseInRawPtr>;
    auto output_by_name( const std::string& name ) const -> IndexAndPort<PortBaseOutRawPtr>;
 
    PortBaseRawPtr port_by_index( const std::string& type, PortIndex index ) const;
    auto input_by_index( PortIndex index ) const { return port_base( m_inputs, index ); }
    auto output_by_index( PortIndex index ) const { return port_base( m_outputs, index ); }
    template <typename T>
    auto input_by_index( PortIndex index ) const {
        return port<T>( m_inputs, index );
    }
    auto input_by_index( PortIndex index ) const  {…}
    template <typename T>
    auto output_by_index( PortIndex index ) const {
        return port<T>( m_outputs, index );
    }
    auto output_by_index( PortIndex index ) const  {…}
 
    const PortBaseInCollection& inputs() const;
 
    const PortBaseOutCollection& outputs() const;
 
 
    const std::string& model_name() const;
    const std::string& display_name() const { return m_display_name; }
    void set_display_name( const std::string& name ) { m_display_name = name; }
 
    const std::string& instance_name() const;
 
    void set_instance_name( const std::string& name );
 
 
 
    void toJson( nlohmann::json& data ) const;
 
    bool fromJson( const nlohmann::json& data );
 
 
    void add_metadata( const nlohmann::json& data );
 
    const nlohmann::json& metadata();
 
    inline bool is_initialized() const { return m_initialized; }
 
    Ra::Core::VariableSet& parameters() { return m_parameters; }
 
    Ra::Core::VariableSet& input_variables();
 
    inline bool is_output();
 
    inline bool is_input();
 
  protected:
    Node( const std::string& instance, const std::string& typeName );
 
    template <typename PortType>
    auto port_by_name( const PortCollection<PortPtr<PortType>>& ports,
                       const std::string& name ) const -> IndexAndPort<PortRawPtr<PortType>>;
    template <typename PortType>
    auto port_base( const PortCollection<PortPtr<PortType>>& ports, PortIndex idx ) const
        -> PortRawPtr<PortType>;
    template <typename T, typename PortType>
    auto port( const PortCollection<PortPtr<PortType>>& ports, PortIndex index ) const {
        return static_cast<typename std::conditional<
            /*if*/ std::is_same<PortBaseIn, PortType>::value,
            /*then*/ PortInRawPtr<T>,
            /*else*/ PortOutRawPtr<T>>::type>( port_base( ports, index ) );
    }
    auto port( const PortCollection<PortPtr<PortType>>& ports, PortIndex index ) const  {…}
    virtual bool fromJsonInternal( const nlohmann::json& data );
    virtual void toJsonInternal( nlohmann::json& data ) const;
    template <typename PortType>
    PortIndex add_port( PortCollection<PortPtr<PortType>>&, PortPtr<PortType> port );
    PortIndex add_input( PortBaseInPtr in );
    PortIndex add_output( PortBaseOutPtr out );
 
    template <typename T, typename... U>
    auto add_input( U&&... u ) {
        auto idx = add_input( std::make_shared<PortIn<T>>( this, std::forward<U>( u )... ) );
        return input_port<T>( idx );
    }
    auto add_input( U&&... u ) {…}
    template <typename T, typename... U>
    auto add_output( U&&... u ) {
        auto idx = add_output( std::make_shared<PortOut<T>>( this, std::forward<U>( u )... ) );
        return output_port<T>( idx );
    }
    auto add_output( U&&... u ) {…}
 
    template <typename T>
    auto input_port( PortIndex index ) {
        return std::static_pointer_cast<PortIn<T>>( m_inputs[index] );
    }
    auto input_port( PortIndex index ) {…}
 
    template <typename T>
    auto output_port( PortIndex index ) {
        return std::static_pointer_cast<PortOut<T>>( m_outputs[index] );
    }
    auto output_port( PortIndex index ) {…}
 
    void remove_input( PortIndex index ) { m_inputs[index].reset(); }
    void remove_output( PortIndex index ) { m_outputs[index].reset(); }
 
    template <typename T>
    auto add_parameter( const std::string& name, const T& value ) {
        return m_parameters.insertVariable<T>( name, value ).first;
    }
 
    template <typename T>
    bool remove_parameter( const std::string& name ) {
        return m_parameters.deleteVariable( name );
    }
 
    template <typename T>
    bool remove_parameter( ParamHandle<T>& handle ) {
        return m_parameters.deleteVariable( handle );
    }
 
    bool m_initialized { false };
    std::string m_model_name;
    std::string m_instance_name;
    std::string m_display_name { "" };
 
    PortCollection<PortPtr<PortBaseIn>> m_inputs;
    PortCollection<PortPtr<PortBaseOut>> m_outputs;
 
    Ra::Core::VariableSet m_parameters;
    Ra::Core::VariableSet m_input_variables;
 
    nlohmann::json m_metadata;
};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
inline void Node::init() {
    m_initialized = true;
}
inline void Node::init() {…}
 
inline void Node::destroy() {
    m_inputs.clear();
    m_outputs.clear();
    m_parameters.clear();
    m_input_variables.clear();
}
inline void Node::destroy() {…}
 
inline const nlohmann::json& Node::metadata() {
    return m_metadata;
}
inline const nlohmann::json& Node::metadata() {…}
 
inline const std::string& Node::model_name() const {
    return m_model_name;
}
inline const std::string& Node::model_name() const  {…}
 
inline const std::string& Node::instance_name() const {
    return m_instance_name;
}
inline const std::string& Node::instance_name() const  {…}
 
inline void Node::set_instance_name( const std::string& newName ) {
    m_instance_name = newName;
}
inline void Node::set_instance_name( const std::string& newName ) {…}
 
inline const Node::PortBaseInCollection& Node::inputs() const {
    return m_inputs;
}
inline const Node::PortBaseInCollection& Node::inputs() const  {…}
 
inline const Node::PortBaseOutCollection& Node::outputs() const {
    return m_outputs;
}
inline const Node::PortBaseOutCollection& Node::outputs() const  {…}
 
inline bool Node::operator==( const Node& node ) {
    return ( m_model_name == node.model_name() ) && ( m_instance_name == node.instance_name() );
}
inline bool Node::operator==( const Node& node ) {…}
 
template <typename PortType>
inline Node::PortIndex Node::add_port( PortCollection<PortPtr<PortType>>& ports,
                                       PortPtr<PortType> port ) {
    PortIndex index;
    // look for a free slot
    auto it = std::find_if( ports.begin(), ports.end(), []( const auto& p ) { return !p; } );
    if ( it != ports.end() ) {
        it->swap( port );
        index = std::distance( ports.begin(), it );
    }
    else {
        ports.push_back( std::move( port ) );
        index = ports.size() - 1;
    }
    return index;
}
inline Node::PortIndex Node::add_port( PortCollection<PortPtr<PortType>>& ports, {…}
 
inline Node::PortIndex Node::add_input( PortBaseInPtr in ) {
    return add_port( m_inputs, std::move( in ) );
}
inline Node::PortIndex Node::add_input( PortBaseInPtr in ) {…}
 
inline Node::PortIndex Node::add_output( PortBaseOutPtr out ) {
    return add_port( m_outputs, std::move( out ) );
}
inline Node::PortIndex Node::add_output( PortBaseOutPtr out ) {…}
    PortIndex add_output( PortBaseOutPtr out ); {…}
 
inline bool Node::compile() {
    return true;
}
inline bool Node::compile() {…}
 
inline Ra::Core::VariableSet& Node::input_variables() {
    m_input_variables.clear();
    for ( const auto& p : m_inputs ) {
        if ( p->has_default_value() ) p->insert( m_input_variables );
    }
 
    return m_input_variables;
}
inline Ra::Core::VariableSet& Node::input_variables() {…}
 
inline bool Node::is_output() {
    bool ret = true;
    for ( const auto& p : m_outputs ) {
        ret = ret && ( p->link_count() == 0 );
    }
    return ret;
}
inline bool Node::is_output() {…}
 
inline bool Node::is_input() {
    bool ret = true;
    //
    for ( const auto& p : m_inputs ) {
        ret = ret && p->has_default_value() && !p->is_linked();
    }
    return ret;
}
inline bool Node::is_input() {…}
 
template <typename PortType>
auto Node::port_by_name( const PortCollection<PortPtr<PortType>>& ports,
                         const std::string& name ) const -> IndexAndPort<PortRawPtr<PortType>> {
    // p might be nullptr if has been removed from ports
    auto itr = std::find_if(
        ports.begin(), ports.end(), [n = name]( const auto& p ) { return p && p->name() == n; } );
    PortRawPtr<PortType> port { nullptr };
    PortIndex portIndex;
    if ( itr != ports.cend() ) {
        port      = itr->get();
        portIndex = std::distance( ports.begin(), itr );
    }
    return { portIndex, port };
}
auto Node::port_by_name( const PortCollection<PortPtr<PortType>>& ports, {…}
 
template <typename PortType>
auto Node::port_base( const PortCollection<PortPtr<PortType>>& ports, PortIndex index ) const
    -> PortRawPtr<PortType> {
    if ( 0 <= index && size_t( index ) < ports.size() ) { return ports[index].get(); }
    return nullptr;
}
auto Node::port_base( const PortCollection<PortPtr<PortType>>& ports, PortIndex index ) const {…}
 
} // namespace Core
} // namespace Dataflow
} // namespace Ra
    PortIndex add_input( PortBaseInPtr in ); {…}
class RA_DATAFLOW_CORE_API Node {…};