node.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
 * Public License. The full license is in the file LICENSE, distributed with
 * this software. */
 
#pragma once
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "gnode/data.hpp"
#include "gnode/port.hpp"
 
namespace gnode
{
 
class Graph; // forward
 
class Node
{
public:
  bool is_dirty = false;
 
  Node() = default;
 
  Node(std::string label) : label(label) {}
 
  Node(std::string label, std::string id) : label(label), id(id) {}
 
  virtual ~Node() = default;
 
  template <typename T, typename... Args>
  void add_port(PortType           port_type,
                const std::string &port_label,
                Args &&...args)
  {
    if (port_type == PortType::IN)
      this->ports.push_back(std::make_shared<gnode::Input<T>>(port_label));
    else
      this->ports.push_back(
          std::make_shared<gnode::Output<T>>(port_label,
                                             std::forward<Args>(args)...));
  }
 
  virtual void compute() = 0;
 
  std::shared_ptr<BaseData> get_base_data(int port_index);
 
  std::shared_ptr<BaseData> get_base_data(const std::string &port_label);
 
  std::string get_data_type(int port_index) const;
 
  std::string get_graph_id() const;
 
  std::string get_label() const { return this->label; }
 
  std::string get_id() const { return this->id; }
 
  int get_nports() const;
 
  int get_nports(PortType port_type) const;
 
  std::shared_ptr<BaseData> get_output_data(int port_index) const;
 
  Graph *get_p_graph() const { return this->p_graph; }
 
  int get_port_index(const std::string &port_label) const;
 
  std::string get_port_label(int port_index) const;
 
  PortType get_port_type(const std::string &port_label) const;
 
  const std::vector<std::shared_ptr<Port>> &get_ports() { return this->ports; };
 
  template <typename T> T *get_value_ref(const std::string &port_label) const
  {
    // Search for the port in the inputs vector
    for (const auto &port : this->ports)
      if (port->get_label() == port_label)
      {
        if (port->get_port_type() == PortType::IN)
        {
          auto inputPort = std::dynamic_pointer_cast<Input<T>>(port);
          if (inputPort) return inputPort->get_value_ref();
        }
        else
        {
          auto outputPort = std::dynamic_pointer_cast<Output<T>>(port);
          if (outputPort) return outputPort->get_value_ref();
        }
      }
 
    // If no matching port is found, throw an exception
    throw std::runtime_error("Port with label '" + port_label + "' not found.");
  }
 
  template <typename T> T *get_value_ref(int port_index) const
  {
    // Range check for the port index
    if (port_index < 0 || port_index >= static_cast<int>(this->ports.size()))
      throw std::out_of_range("Invalid port index");
 
    // Dynamic cast to the appropriate port type (Input or Output) and return
    // the value reference if the port is valid, otherwise return nullptr
    if (this->ports[port_index]->get_port_type() == PortType::IN)
    {
      auto port = std::dynamic_pointer_cast<Input<T>>(this->ports[port_index]);
      return port ? port->get_value_ref() : nullptr;
    }
    else
    {
      auto port = std::dynamic_pointer_cast<Output<T>>(this->ports[port_index]);
      return port ? port->get_value_ref() : nullptr;
    }
  }
 
  void *get_value_ref_void(int port_index) const
  {
    if (port_index < 0 || port_index >= static_cast<int>(this->ports.size()))
      throw std::out_of_range("Invalid port index");
 
    return this->ports[port_index]->get_value_ref_void();
  }
 
  bool is_port_connected(int port_index) const;
 
  bool is_port_connected(const std::string &port_label) const;
 
  void set_id(std::string new_id) { this->id = new_id; }
 
  void set_input_data(std::shared_ptr<BaseData> data, int port_index);
 
  void set_p_graph(Graph *new_p_graph) { this->p_graph = new_p_graph; }
 
  template <typename T>
  void set_value(const std::string &port_label, T new_value)
  {
    T *p_value = this->get_value_ref<T>(port_label);
    *p_value = new_value;
  }
 
  void update();
 
private:
  std::string label;
 
  std::string id;
 
  std::vector<std::shared_ptr<Port>> ports;
 
  Graph *p_graph = nullptr;
};
 
} // namespace gnode