graph.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 <functional>
#include <map>
#include <memory>
 
#include "gnode/link.hpp"
#include "gnode/node.hpp"
#include "gnode/point.hpp"
 
typedef unsigned int uint;
 
namespace gnode
{
 
class Graph
{
public:
  Graph() = default;
 
  Graph(const std::string &id) : id(id) {}
 
  virtual ~Graph() = default;
 
  virtual std::string add_node(const std::shared_ptr<Node> &p_node,
                               const std::string           &id = "");
 
  template <typename U, typename... Args> std::string add_node(Args... args)
  {
    return this->add_node(std::make_shared<U>(args...));
  }
 
  void clear();
 
  std::vector<Point> compute_graph_layout_sugiyama();
 
  std::string get_id() const { return this->id; };
 
  bool new_link(const std::string &from,
                int                port_from,
                const std::string &to,
                int                port_to);
 
  bool new_link(const std::string &from,
                const std::string &port_label_from,
                const std::string &to,
                const std::string &port_label_to);
 
  bool remove_link(const std::string &from,
                   int                port_from,
                   const std::string &to,
                   int                port_to);
 
  bool remove_link(const std::string &from,
                   const std::string &port_label_from,
                   const std::string &to,
                   const std::string &port_label_to);
 
  void export_to_graphviz(const std::string &fname = "export.dot",
                          const std::string &graph_label = "graph");
 
  void export_to_mermaid(const std::string &fname = "export.mmd",
                         const std::string &graph_label = "graph");
 
  std::map<std::string, std::vector<std::string>> get_connectivity_downstream();
 
  std::map<std::string, std::vector<std::string>> get_connectivity_upstream();
 
  uint get_id_count() const { return this->id_count; }
 
  uint *get_id_count_ref() { return &this->id_count; }
 
  const std::vector<Link> &get_links() const { return this->links; }
 
  template <typename T = Node>
  T *get_node_ref_by_id(const std::string &node_id) const
  {
    auto it = nodes.find(node_id);
    if (it == nodes.end()) return nullptr;
 
    T *ptr = dynamic_cast<T *>(it->second.get());
    if (!ptr)
      throw std::runtime_error("Failed to cast node with ID: " + node_id +
                               " to the specified type.");
 
    return ptr;
  }
 
  const std::map<std::string, std::shared_ptr<Node>> &get_nodes()
  {
    return this->nodes;
  }
 
  std::vector<std::string> get_nodes_to_update(const std::string &node_id);
 
  bool is_node_id_available(const std::string &node_id);
 
  virtual void post_update() {}
 
  void print();
 
  virtual void remove_node(const std::string &id);
 
  void set_id(const std::string &new_id) { this->id = new_id; };
 
  void set_id_count(uint new_id_count) { this->id_count = new_id_count; }
 
  void set_update_callback(std::function<void(const std::string &,
                                              const std::vector<std::string> &,
                                              bool)> new_callback)
  {
    this->update_callback = new_callback;
  }
 
  std::vector<std::string> topological_sort(
      const std::vector<std::string> &dirty_node_ids);
 
  virtual void update();
 
  virtual void update(const std::string &node_id);
 
protected:
  std::map<std::string, std::shared_ptr<Node>> nodes;
 
  std::vector<Link> links;
 
private:
  uint id_count = 0;
 
  std::string id = "";
 
  std::function<void(const std::string              &current_id,
                     const std::vector<std::string> &sorted_ids,
                     bool                            before_update)>
      update_callback = nullptr;
};
 
// helper
 
template <typename T> bool contains(const std::vector<T> &vec, const T &value)
{
  return std::find(vec.begin(), vec.end(), value) != vec.end();
}
 
} // namespace gnode