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() const
  {
    return this->ports;
  };
 
  template <typename T> T *get_value_ref(const std::string &port_label) const
  {
    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)
            throw std::runtime_error("Type mismatch for port: " + port_label);
          return inputPort->get_value_ref();
        }
        else
        {
          auto outputPort = std::dynamic_pointer_cast<Output<T>>(port);
          if (!outputPort)
            throw std::runtime_error("Type mismatch for port: " + port_label);
          return outputPort->get_value_ref();
        }
      }
    }
    throw std::runtime_error("Port not found: " + port_label);
  }
 
  template <typename T> T *get_value_ref(int port_index) const
  {
    if (port_index < 0 || port_index >= static_cast<int>(this->ports.size()))
      throw std::out_of_range("Port index is out of range: " +
                              std::to_string(port_index));
 
    if (this->ports[port_index]->get_port_type() == PortType::IN)
    {
      auto port = std::dynamic_pointer_cast<Input<T>>(this->ports[port_index]);
      if (!port)
        throw std::runtime_error("Type mismatch for port index: " +
                                 std::to_string(port_index));
      return port->get_value_ref();
    }
    else
    {
      auto port = std::dynamic_pointer_cast<Output<T>>(this->ports[port_index]);
      if (!port)
        throw std::runtime_error("Type mismatch for port index: " +
                                 std::to_string(port_index));
      return port->get_value_ref();
    }
  }
 
  void *get_value_ref_void(int port_index) const
  {
    if (port_index < 0 || port_index >= static_cast<int>(this->ports.size()))
      return nullptr;
 
    return this->ports[port_index]->get_value_ref_void();
  }
 
  bool has_port(const std::string &port_label) const;
 
  template <typename T> bool has_port(const std::string &port_label) const
  {
    int index = this->get_port_index(port_label);
    if (index == -1) return false;
    return this->ports[index]->get_data_type() == typeid(T).name();
  }
 
  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);
    if (!p_value)
      throw std::runtime_error("set_value: cannot set value: " + 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