SinkNode.hpp

#pragma once
#include <Core/Utils/TypesUtils.hpp>
#include <Dataflow/Core/Node.hpp>
#include <stdexcept>
 
namespace Ra {
namespace Dataflow {
namespace Core {
namespace Sinks {
 
template <typename T>
class SinkNode : public Node
{
  protected:
    SinkNode( const std::string& instanceName, const std::string& typeName );
 
  public:
    explicit SinkNode( const std::string& name ) : SinkNode( name, SinkNode<T>::node_typename() ) {}
 
    void init() override;
    bool execute() override;
 
    T data() const;
    const T& data_reference() const;
 
  protected:
    void toJsonInternal( nlohmann::json& data ) const override { Node::toJsonInternal( data ); }
    bool fromJsonInternal( const nlohmann::json& data ) override {
        return Node::fromJsonInternal( data );
    }
    bool fromJsonInternal( const nlohmann::json& data ) override  {…}
 
  private:
    RA_NODE_PORT_IN( T, from );
    RA_NODE_PORT_OUT( T, data );
  public:
    static const std::string& node_typename();
};
class SinkNode : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename T>
SinkNode<T>::SinkNode( const std::string& instanceName, const std::string& typeName ) :
    Node( instanceName, typeName ) {}
 
template <typename T>
void SinkNode<T>::init() {
    Node::init();
}
void SinkNode<T>::init() {…}
 
template <typename T>
bool SinkNode<T>::execute() {
    if ( is_initialized() && m_port_in_from->has_data() ) {
        m_port_out_data->set_data( &m_port_in_from->data() );
        return true;
    }
    return false;
}
bool SinkNode<T>::execute() {…}
 
template <typename T>
T SinkNode<T>::data() const {
    if ( m_port_out_data->has_data() ) return m_port_out_data->data();
    throw std::runtime_error( "Sink out port hasn't data" );
}
T SinkNode<T>::data() const  {…}
 
template <typename T>
const T& SinkNode<T>::data_reference() const {
    if ( m_port_out_data->has_data() ) return m_port_out_data->data();
    throw std::runtime_error( "Sink out port hasn't data" );
}
const T& SinkNode<T>::data_reference() const  {…}
 
template <typename T>
const std::string& SinkNode<T>::node_typename() {
    static std::string demangledName =
        std::string { "Sink<" } + Ra::Core::Utils::simplifiedDemangledType<T>() + ">";
    return demangledName;
}
 
} // namespace Sinks
} // namespace Core
} // namespace Dataflow
} // namespace Ra