TransformNode.hpp

#pragma once
#include <Core/Utils/TypesUtils.hpp>
#include <Dataflow/Core/Node.hpp>
 
#include <functional>
 
namespace Ra {
namespace Dataflow {
namespace Core {
namespace Functionals {
 
template <typename coll_t, typename v_t = typename coll_t::value_type>
class TransformNode : public Node
{
  public:
    using TransformOperator = std::function<v_t( const v_t& )>;
 
    explicit TransformNode( const std::string& instanceName );
 
    TransformNode( const std::string& instanceName, TransformOperator op );
 
    void init() override;
    bool execute() override;
 
    void set_operator( TransformOperator op );
 
  protected:
    TransformNode( const std::string& instanceName,
                   const std::string& typeName,
                   TransformOperator op );
 
    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( coll_t, data );
    RA_NODE_PORT_IN( TransformOperator, op );
    RA_NODE_PORT_OUT_WITH_DATA( coll_t, result );
 
  public:
    static const std::string& node_typename();
};
class TransformNode : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename coll_t, typename v_t>
TransformNode<coll_t, v_t>::TransformNode( const std::string& instanceName ) :
    TransformNode( instanceName, node_typename(), []( v_t ) { return v_t {}; } ) {}
TransformNode<coll_t, v_t>::TransformNode( const std::string& instanceName ) : {…}
 
template <typename coll_t, typename v_t>
TransformNode<coll_t, v_t>::TransformNode( const std::string& instanceName, TransformOperator op ) :
    TransformNode( instanceName, node_typename(), op ) {}
TransformNode<coll_t, v_t>::TransformNode( const std::string& instanceName, TransformOperator op ) : {…}
 
template <typename coll_t, typename v_t>
void TransformNode<coll_t, v_t>::set_operator( TransformOperator op ) {
    m_port_in_op->set_default_value( op );
}
void TransformNode<coll_t, v_t>::set_operator( TransformOperator op ) {…}
 
template <typename coll_t, typename v_t>
void TransformNode<coll_t, v_t>::init() {
    Node::init();
    m_result.clear();
}
void TransformNode<coll_t, v_t>::init() {…}
 
template <typename coll_t, typename v_t>
bool TransformNode<coll_t, v_t>::execute() {
    const auto& f      = m_port_in_op->data();
    const auto& inData = m_port_in_data->data();
    m_result.clear();
    // m_elements.reserve( inData.size() ); // --> this is not a requirement of
    // SequenceContainer
    std::transform( inData.begin(), inData.end(), std::back_inserter( m_result ), f );
 
    return true;
}
bool TransformNode<coll_t, v_t>::execute() {…}
 
template <typename coll_t, typename v_t>
const std::string& TransformNode<coll_t, v_t>::node_typename() {
    static std::string demangledName =
        std::string { "Transform<" } + Ra::Core::Utils::simplifiedDemangledType<coll_t>() + ">";
    return demangledName;
}
 
template <typename coll_t, typename v_t>
TransformNode<coll_t, v_t>::TransformNode( const std::string& instanceName,
                                           const std::string& typeName,
                                           TransformOperator op ) :
    Node( instanceName, typeName ) {
    m_port_in_op->set_default_value( op );
}
 
} // namespace Functionals
} // namespace Core
} // namespace Dataflow
} // namespace Ra