BinaryOpNode.hpp

#pragma once
#include "Core/CoreMacros.hpp"
#include "Dataflow/Core/Port.hpp"
#include <Dataflow/Core/Node.hpp>
 
#include <functional>
 
namespace Ra {
namespace Dataflow {
namespace Core {
namespace Functionals {
 
namespace internal {
 
template <typename A, bool is_container = false>
struct ArgTypeHelperInternal {
    using value_type      = A;
    using const_value_ref = const A&;
};
struct ArgTypeHelperInternal {…};
 
template <typename A>
struct ArgTypeHelperInternal<A, true> {
    using value_type      = typename A::value_type;
    using const_value_ref = const typename A::value_type&;
};
struct ArgTypeHelperInternal<A, true> {…};
 
template <typename A>
struct ArgTypeHelper : public ArgTypeHelperInternal<A, Ra::Core::Utils::is_container<A>::value> {};
 
// Find a way to evaluate the copy/move semantic of t_out
template <typename t_a,
          typename t_b,
          typename t_out,
          typename funcType,
          bool it_a   = Ra::Core::Utils::is_container<t_a>::value,
          bool it_b   = Ra::Core::Utils::is_container<t_b>::value,
          bool it_out = Ra::Core::Utils::is_container<t_out>::value>
struct ExecutorHelper {
    static t_out executeInternal( t_a&, t_b&, funcType ) {
        static_assert( ( ( it_a || it_b ) ? it_out : !it_out ), "Invalid template parameter " );
    }
};
struct ExecutorHelper {…};
 
template <typename t_a, typename t_b, typename t_out, typename funcType>
struct ExecutorHelper<t_a, t_b, t_out, funcType, true, true, true> {
    static t_out executeInternal( t_a& a, t_b& b, funcType f ) {
        t_out res;
        std::transform( a.begin(),
                        a.end(),
                        b.begin(),
                        std::back_inserter( res ),
                        [f]( typename ArgTypeHelper<t_a>::const_value_ref x,
                             typename ArgTypeHelper<t_b>::const_value_ref y ) ->
                        typename ArgTypeHelper<t_out>::value_type { return f( x, y ); } );
        return res;
    }
};
struct ExecutorHelper<t_a, t_b, t_out, funcType, true, true, true> {…};
 
template <typename t_a, typename t_b, typename t_out, typename funcType>
struct ExecutorHelper<t_a, t_b, t_out, funcType, true, false, true> {
    static t_out executeInternal( t_a& a, t_b& b, funcType f ) {
        t_out res;
        std::transform( a.begin(),
                        a.end(),
                        std::back_inserter( res ),
                        [&b, f]( typename ArgTypeHelper<t_a>::const_value_ref x ) ->
                        typename ArgTypeHelper<t_out>::value_type { return f( x, b ); } );
        return res;
    }
};
struct ExecutorHelper<t_a, t_b, t_out, funcType, true, false, true> {…};
 
template <typename t_a, typename t_b, typename t_out, typename funcType>
struct ExecutorHelper<t_a, t_b, t_out, funcType, false, true, true> {
    static t_out executeInternal( t_a& a, t_b& b, funcType f ) {
        t_out res;
        std::transform( b.begin(),
                        b.end(),
                        std::back_inserter( res ),
                        [&a, f]( typename ArgTypeHelper<t_b>::const_value_ref x ) ->
                        typename ArgTypeHelper<t_out>::value_type { return f( a, x ); } );
        return res;
    }
};
struct ExecutorHelper<t_a, t_b, t_out, funcType, false, true, true> {…};
 
template <typename t_a, typename t_b, typename t_out, typename funcType>
struct ExecutorHelper<t_a, t_b, t_out, funcType, false, false, false> {
    static t_out executeInternal( t_a& a, t_b& b, funcType f ) { return f( a, b ); }
};
struct ExecutorHelper<t_a, t_b, t_out, funcType, false, false, false> {…};
} // namespace internal
namespace internal {…}
 
template <typename t_a, typename t_b = t_a, typename t_result = t_a>
class BinaryOpNode : public Node
{
  public:
    using Arg1_type      = typename internal::ArgTypeHelper<t_a>::const_value_ref;
    using Arg2_type      = typename internal::ArgTypeHelper<t_b>::const_value_ref;
    using Res_type       = typename internal::ArgTypeHelper<t_result>::value_type;
    using BinaryOperator = std::function<Res_type( Arg1_type, Arg2_type )>;
 
    BinaryOpNode( const std::string& instanceName, std::optional<BinaryOperator> op = {} ) :
        BinaryOpNode( instanceName, node_typename(), op ) {}
    BinaryOpNode( const std::string& instanceName, std::optional<BinaryOperator> op = {} ) : {…}
 
    void init() override {
        m_result = t_result {};
        Node::init();
    }
    void init() override  {…}
 
    bool execute() override {
 
        const auto& f = m_port_in_op->data();
        m_result = internal::ExecutorHelper<t_a, t_b, t_result, BinaryOperator>::executeInternal(
            m_port_in_a->data(), m_port_in_b->data(), f );
        return true;
    }
    bool execute() override  {…}
 
    void set_operator( BinaryOperator op ) { m_port_in_op->set_default_value( op ); }
 
    static const std::string& node_typename() {
        static std::string demangledName =
            std::string { "BinaryOp<" } + Ra::Core::Utils::simplifiedDemangledType<t_a>() + " x " +
            Ra::Core::Utils::simplifiedDemangledType<t_b>() + " -> " +
            Ra::Core::Utils::simplifiedDemangledType<t_result>() + ">";
        return demangledName;
    }
 
  protected:
    BinaryOpNode( const std::string& instanceName,
                  const std::string& typeName,
                  std::optional<BinaryOperator> op ) :
        Node( instanceName, typeName ) {
        if ( op ) m_port_in_op->set_default_value( *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( t_a, a );
    RA_NODE_PORT_IN( t_b, b );
    RA_NODE_PORT_IN( BinaryOperator, op );
    RA_NODE_PORT_OUT_WITH_DATA( t_result, result );
};
class BinaryOpNode : public Node {…};
 
} // namespace Functionals
} // namespace Core
} // namespace Dataflow
} // namespace Ra