Port.hpp

#pragma once
 
#include "Core/Utils/Color.hpp"
#include <Core/Types.hpp>
#include <Dataflow/RaDataflow.hpp>
 
#include <Core/Utils/TypesUtils.hpp>
 
#include <string>
 
namespace Ra {
namespace Dataflow {
namespace Core {
 
class Node;
 
// forward, defined in port facotory
template <typename T>
void add_port_type();
class RA_DATAFLOW_CORE_API PortBase
{
  public:
    PortBase()                             = delete;
    PortBase( const PortBase& )            = delete;
    PortBase& operator=( const PortBase& ) = delete;
    PortBase( const std::string& name, std::type_index type, Node* node ) :
        m_name( name ), m_type( type ), m_node( node ) {}
    PortBase( const std::string& name, std::type_index type, Node* node ) : {…}
 
    virtual ~PortBase() = default;
 
    const std::string& name() const { return m_name; }
    void set_name( const std::string& name ) { m_name = name; }
    std::type_index type() const { return m_type; }
    Node* node() const { return m_node; }
 
    std::string port_typename() const { return Ra::Core::Utils::simplifiedDemangledType( m_type ); }
 
    virtual bool has_data() = 0;
 
    virtual void to_json( nlohmann::json& data ) { data["name"] = name(); }
    virtual void from_json( const nlohmann::json& data ) {
        if ( auto it = data.find( "name" ); it != data.end() ) { set_name( *it ); }
    }
 
  private:
    std::string m_name { "" }; 
    std::type_index m_type;    
    Node* m_node { nullptr };  
};
class RA_DATAFLOW_CORE_API PortBase {…};
 
template <typename Port>
using PortPtr = std::shared_ptr<Port>;
 
template <typename Port>
using PortRawPtr = typename PortPtr<Port>::element_type*;
 
using PortBasePtr    = PortPtr<PortBase>;
using PortBaseRawPtr = PortRawPtr<PortBase>;
 
} // namespace Core
} // namespace Dataflow
} // namespace Ra