FilterNode.hpp

#pragma once
#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 FilterNode : public Node
{
  public:
    using UnaryPredicate = std::function<bool( const v_t& )>;
 
    explicit FilterNode( const std::string& instanceName );
 
    FilterNode( const std::string& instanceName, UnaryPredicate predicate );
 
    void init() override;
    bool execute() override;
 
    void set_predicate( UnaryPredicate predicate );
 
  protected:
    FilterNode( const std::string& instanceName,
                const std::string& typeName,
                UnaryPredicate predicate );
 
    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( UnaryPredicate, predicate );
    RA_NODE_PORT_OUT_WITH_DATA( coll_t, result );
 
  public:
    static const std::string& node_typename();
};
class FilterNode : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename coll_t, typename v_t>
FilterNode<coll_t, v_t>::FilterNode( const std::string& instanceName ) :
    FilterNode( instanceName, node_typename(), []( v_t ) { return true; } ) {}
FilterNode<coll_t, v_t>::FilterNode( const std::string& instanceName ) : {…}
 
template <typename coll_t, typename v_t>
FilterNode<coll_t, v_t>::FilterNode( const std::string& instanceName, UnaryPredicate predicate ) :
    FilterNode( instanceName, node_typename(), predicate ) {}
FilterNode<coll_t, v_t>::FilterNode( const std::string& instanceName, UnaryPredicate predicate ) : {…}
 
template <typename coll_t, typename v_t>
void FilterNode<coll_t, v_t>::set_predicate( UnaryPredicate predicate ) {
    m_port_in_predicate->set_default_value( predicate );
}
void FilterNode<coll_t, v_t>::set_predicate( UnaryPredicate predicate ) {…}
 
template <typename coll_t, typename v_t>
void FilterNode<coll_t, v_t>::init() {
    Node::init();
    m_result.clear();
}
void FilterNode<coll_t, v_t>::init() {…}
 
template <typename coll_t, typename v_t>
bool FilterNode<coll_t, v_t>::execute() {
    const auto& f      = m_port_in_predicate->data();
    const auto& inData = m_port_in_data->data();
    m_result.clear();
    // since we do not know how many inData respect the predicate, do not reserve m_result
    std::copy_if( inData.begin(), inData.end(), std::back_inserter( m_result ), f );
 
    return true;
}
bool FilterNode<coll_t, v_t>::execute() {…}
 
template <typename coll_t, typename v_t>
const std::string& FilterNode<coll_t, v_t>::node_typename() {
    static std::string demangledName =
        std::string { "Filter<" } + Ra::Core::Utils::simplifiedDemangledType<coll_t>() + ">";
    return demangledName;
}
 
template <typename coll_t, typename v_t>
FilterNode<coll_t, v_t>::FilterNode( const std::string& instanceName,
                                     const std::string& typeName,
                                     UnaryPredicate predicate ) :
    Node( instanceName, typeName ) {
    m_port_in_predicate->set_default_value( predicate );
}
 
} // namespace Functionals
} // namespace Core
} // namespace Dataflow
} // namespace Ra