FunctionSource.hpp

#pragma once
#include "Dataflow/Core/NodeFactory.hpp"
#pragma once
#include <Dataflow/Core/Node.hpp>
 
#include <iostream>
#include <utility>
 
namespace Ra {
namespace Dataflow {
namespace Core {
namespace Sources {
 
template <class R, class... Args>
class FunctionSourceNode : public Node
{
 
  public:
    using function_type = std::function<R( Args... )>;
 
    explicit FunctionSourceNode( const std::string& name ) :
        FunctionSourceNode( name, FunctionSourceNode<R, Args...>::node_typename() ) {}
 
    bool execute() override;
 
    void set_data( function_type data );
 
    function_type* data() const;
 
  protected:
    FunctionSourceNode( const std::string& instanceName, const std::string& typeName );
 
    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 { Node::toJsonInternal( data ); }
 
    RA_NODE_PORT_IN( function_type, from );
    RA_NODE_PORT_OUT( function_type, to );
 
  public:
    static const std::string& node_typename();
};
class FunctionSourceNode : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <class R, class... Args>
FunctionSourceNode<R, Args...>::FunctionSourceNode( const std::string& instanceName,
                                                    const std::string& typeName ) :
    Node( instanceName, typeName ) {
    m_port_in_from->set_default_value( []( Args... ) { return R {}; } );
    m_port_out_to->set_data( &m_port_in_from->data() );
}
 
template <class R, class... Args>
bool FunctionSourceNode<R, Args...>::execute() {
    return true;
}
bool FunctionSourceNode<R, Args...>::execute() {…}
 
template <class R, class... Args>
void FunctionSourceNode<R, Args...>::set_data( function_type data ) {
    m_port_in_from->set_default_value( std::move( data ) );
    m_port_out_to->set_data( &m_port_in_from->data() );
}
void FunctionSourceNode<R, Args...>::set_data( function_type data ) {…}
 
template <class R, class... Args>
typename FunctionSourceNode<R, Args...>::function_type*
FunctionSourceNode<R, Args...>::data() const {
    return m_port_in_from->data();
}
FunctionSourceNode<R, Args...>::data() const  {…}
 
template <class R, class... Args>
const std::string& FunctionSourceNode<R, Args...>::node_typename() {
    static std::string demangledTypeName =
        std::string { "Source<" } + Ra::Core::Utils::simplifiedDemangledType<function_type>() + ">";
    return demangledTypeName;
}
 
} // namespace Sources
} // namespace Core
} // namespace Dataflow
} // namespace Ra