SingleDataSourceNode.hpp

#pragma once
 
#include <Core/Containers/VariableSet.hpp>
#include <Core/Utils/TypesUtils.hpp>
#include <Dataflow/Core/Node.hpp>
 
#include <iostream>
#include <nlohmann/json.hpp>
#include <utility>
 
namespace Ra {
namespace Dataflow {
namespace Core {
namespace Sources {
 
template <typename T>
class SingleDataSourceNode : public Node
{
  protected:
    SingleDataSourceNode( const std::string& instanceName, const std::string& typeName );
 
  public:
    // warning, hacky specialization for set editable
    explicit SingleDataSourceNode( const std::string& name ) :
        SingleDataSourceNode( name, SingleDataSourceNode<T>::node_typename() ) {}
 
    bool execute() override;
 
    void set_data( T data );
 
    T* data() const;
 
  protected:
    bool fromJsonInternal( const nlohmann::json& data ) override {
        return Node::fromJsonInternal( data );
    }
    bool fromJsonInternal( const nlohmann::json& data ) override  {…}
 
    void toJsonInternal( nlohmann::json& data ) const override {
        return Node::toJsonInternal( data );
    }
    void toJsonInternal( nlohmann::json& data ) const override  {…}
 
  private:
    RA_NODE_PORT_IN( T, from );
    RA_NODE_PORT_OUT( T, to );
 
  public:
    static const std::string& node_typename();
};
class SingleDataSourceNode : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename T>
SingleDataSourceNode<T>::SingleDataSourceNode( const std::string& instanceName,
                                               const std::string& typeName ) :
    Node( instanceName, typeName ) {
    m_port_in_from->set_default_value( T {} );
    m_port_out_to->set_data( &m_port_in_from->data() );
}
 
template <typename T>
bool SingleDataSourceNode<T>::execute() {
    // update ouput in case input has changed (if not default value))
    m_port_out_to->set_data( &m_port_in_from->data() );
    return true;
}
bool SingleDataSourceNode<T>::execute() {…}
 
template <typename T>
void SingleDataSourceNode<T>::set_data( T data ) {
    m_port_in_from->set_default_value( std::move( data ) );
    m_port_out_to->set_data( &m_port_in_from->data() );
}
void SingleDataSourceNode<T>::set_data( T data ) {…}
 
template <typename T>
T* SingleDataSourceNode<T>::data() const {
    return &( m_port_in_from->data() );
}
T* SingleDataSourceNode<T>::data() const  {…}
 
template <typename T>
const std::string& SingleDataSourceNode<T>::node_typename() {
    static std::string demangledTypeName =
        std::string { "Source<" } + Ra::Core::Utils::simplifiedDemangledType<T>() + ">";
    return demangledTypeName;
}
 
} // namespace Sources
} // namespace Core
} // namespace Dataflow
} // namespace Ra