dag_node_impl.hpp

#pragma once
 
#include <iostream>
#include <string>
 
#include "functional_dag/core/dag_utils.hpp"
#include "functional_dag/dag_interface.hpp"
#include "functional_dag/impl/dag_fanout_impl.hpp"
 
namespace fn_dag {
using namespace std;
 
// Forward declaration of dag_fanout_node
template <typename Out, typename IDType>
class dag_fanout_node;

template <class Type, class IDType>
class _abstract_internal_dag_node {
 public:
  virtual ~_abstract_internal_dag_node() = default;
  virtual const IDType &get_id() = 0;
  virtual void run_filter(const Type *const _data) = 0;
  virtual void print(const string &_plus) = 0;
};

template <typename In, typename Out, typename IDType>
class _internal_dag_node : public _abstract_internal_dag_node<In, IDType> {
  friend class dag_fanout_node<In, IDType>;  // Friend classing fanout for the
                                             // add_node search
 
 private:
  dag_node<In, Out> *m_node_hook;  // The function to run
  const IDType m_node_id;          // The ID of the node
  dag_fanout_node<Out, IDType>
      *m_child;  // All of the children to provide our output data to.
  const fn_dag::_dag_context
      &g_context;  // A hook to the global context of this DAG.
 
 public:
  _internal_dag_node(IDType _node_id, dag_node<In, Out> *_node,
                     const fn_dag::_dag_context &_context)
      : m_node_hook(_node),
        m_node_id(_node_id),
        m_child(new dag_fanout_node<Out, IDType>(_context)),
        g_context(_context) {}

  ~_internal_dag_node() {
    delete m_child;
    delete m_node_hook;
  }

  void run_filter(const In *const _data) {
    unique_ptr<Out> data_out = m_node_hook->update(_data);
    if (!g_context.filter_off && data_out != nullptr)
      m_child->fan_out(std::move(data_out));
  }

  void print(const string &_indent_str) {
    *g_context.log << m_node_id << endl;
    m_child->print(_indent_str);
  }

  const IDType &get_id() { return m_node_id; }
};
}  // namespace fn_dag