PortOut.hpp

#pragma once
 
#include <Dataflow/RaDataflow.hpp>
 
#include <Core/Utils/Log.hpp>
#include <Core/Utils/TypesUtils.hpp>
 
#include <Dataflow/Core/Port.hpp>
#include <stdexcept>
 
namespace Ra {
namespace Dataflow {
namespace Core {
 
class PortBaseIn; 
template <typename T>
class PortIn;
 
class RA_DATAFLOW_CORE_API PortBaseOut : public PortBase
{
  public:
    PortBaseOut()                                = delete;
    PortBaseOut( const PortBaseOut& )            = delete;
    PortBaseOut& operator=( const PortBaseOut& ) = delete;
 
    template <typename T>
    T& data();
 
    template <typename T>
    void set_data( T* data );
 
    // called by PortIn when connect
    virtual void increase_link_count() {
        ++m_linkCount;
        CORE_ASSERT( m_linkCount >= 0, "link count error" );
    }
 
    // called by PortIn when disconnect
    virtual void decrease_link_count() {
        --m_linkCount;
        CORE_ASSERT( m_linkCount >= 0, "link count error" );
    }
    virtual int link_count() { return m_linkCount; }
 
  protected:
    PortBaseOut( Node* node, const std::string& name, std::type_index type );
    int m_linkCount { 0 };
 
}; // class PortBaseOut
 
template <typename T>
class PortOut : public PortBaseOut
{
  public:
    using DataType = T;
 
    PortOut()                            = delete;
    PortOut( const PortOut& )            = delete;
    PortOut& operator=( const PortOut& ) = delete;
 
    PortOut( Node* node, const std::string& name ) : PortBaseOut( node, name, typeid( T ) ) {
        add_port_type<T>();
    }
    PortOut( Node* node, const std::string& name ) : PortBaseOut( node, name, typeid( T ) ) {…}
 
    PortOut( Node* node, T* data, const std::string& name ) :
        PortBaseOut( node, name, typeid( T ) ), m_data { data } {
        add_port_type<T>();
    }
 
    T& data() { return *m_data; }
    void set_data( T* data ) { m_data = data; }
    bool has_data() override { return ( m_data ); }
 
  private:
    T* m_data { nullptr };
 
}; // class PortOut<T>
class PortOut : public PortBaseOut {…};
 
template <typename Type>
using PortOutPtr = PortPtr<PortOut<Type>>;
template <typename Type>
using PortOutRawPtr = typename PortOutPtr<Type>::element_type*;
 
using PortBaseOutRawPtr = PortRawPtr<PortBaseOut>;
using PortBaseOutPtr    = PortPtr<PortBaseOut>;
 
template <typename T>
T& PortBaseOut::data() {
    auto thisOut = dynamic_cast<PortOut<T>*>( this );
    if ( thisOut && thisOut->has_data() ) { return thisOut->data(); }
 
    using namespace Ra::Core::Utils;
    LOG( Ra::Core::Utils::logERROR )
        << "Unable to get data with type " << simplifiedDemangledType<T>() << " on port " << name()
        << " which expect " << port_typename() << ".\n";
    throw std::runtime_error( "data reference do not exists" );
}
 
template <typename T>
void PortBaseOut::set_data( T* data ) {
    auto thisOut = dynamic_cast<PortOut<T>*>( this );
    if ( thisOut ) {
        thisOut->set_data( data );
        return;
    }
 
    using namespace Ra::Core::Utils;
    LOG( Ra::Core::Utils::logERROR )
        << "Unable to set data with type " << simplifiedDemangledType( *data ) << " on port "
        << name() << " which expect " << port_typename() << ".\n";
    throw std::runtime_error( "data reference do not exists" );
}
 
} // namespace Core
} // namespace Dataflow
} // namespace Ra