Node.h

#ifndef PROFILER_SRC_MOLPRO_PROFILER_TREE_NODE_H
#define PROFILER_SRC_MOLPRO_PROFILER_TREE_NODE_H
#include <list>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
 
namespace molpro {
namespace profiler {
 
struct NodePathError : std::runtime_error {
  using std::runtime_error::runtime_error;
};
 
template <class Counter>
class Node {
private:
  explicit Node(std::string name, Counter counter, std::shared_ptr<Node<Counter>> parent)
      : name(std::move(name)), counter(std::move(counter)), parent(std::move(parent)) {}
 
public:
  ~Node() = default;
  Node(Node<Counter>&&) noexcept = default;
  Node<Counter>& operator=(Node<Counter>&&) noexcept = default;
 
  Node(const Node<Counter>&) = delete;
  Node<Counter>& operator=(const Node<Counter>&) = delete;
 
  static std::shared_ptr<Node<Counter>> make_root(const std::string& name, const Counter& counter) {
    return std::make_shared<Node<Counter>>(Node<Counter>(name, counter, nullptr));
  }
 
  static std::shared_ptr<Node<Counter>> add_child(const std::string& child_name, const Counter& child_counter,
                                                  const std::shared_ptr<Node<Counter>>& parent) {
    auto child = std::make_shared<Node<Counter>>(Node<Counter>(child_name, child_counter, parent));
    parent->children[child_name] = child;
    return child;
  }
 
  static std::shared_ptr<Node<Counter>> deep_copy(const std::shared_ptr<Node<Counter>>& subtree,
                                                  std::shared_ptr<Node<Counter>> parent) {
    auto tree_copy = make_root(subtree->name, subtree->counter);
    tree_copy->parent = std::move(parent);
    for (auto& child : subtree->children)
      tree_copy->children[child.first] = deep_copy(child.second, tree_copy);
    return tree_copy;
  }
 
  template <typename ForwardIt>
  std::shared_ptr<Node<Counter>> walk(ForwardIt start_name, ForwardIt end_name) {
    auto it = children.find(*start_name);
    if (it == end(children))
      throw NodePathError(std::string("Child was not found. Path is invalid."));
    if (++start_name == end_name)
      return it->second;
    else
      return it->second->walk(start_name, end_name);
  }
 
  std::shared_ptr<Node<Counter>> walk(const std::list<std::string>& path_to_node) {
    return walk(begin(path_to_node), end(path_to_node));
  }
 
  std::shared_ptr<Node<Counter>> child(const std::string& child_name) { return walk({child_name}); }
 
  std::shared_ptr<Node<Counter>> find_parent(const std::string& parent_name) {
    auto node = this;
    while (node->parent != nullptr && node->parent->name != parent_name) {
      node = node->parent.get();
    }
    return node->parent;
  }
 
  std::shared_ptr<Node<Counter>> walk_up(int n) {
    if (n < 1)
      throw NodePathError("n must be > 0");
    std::shared_ptr<Node<Counter>> node = parent;
    while (--n > 0 && node != nullptr) {
      node = node->parent;
    }
    return node;
  }
 
  size_t count_nodes() const {
    size_t n = 1;
    for (auto& child : children)
      n += child.second->count_nodes();
    return n;
  }
 
  std::string name; 
  Counter counter;  
  std::shared_ptr<Node<Counter>> parent = nullptr;                
  std::map<std::string, std::shared_ptr<Node<Counter>>> children; 
};
 
} // namespace profiler
} // namespace molpro
#endif // PROFILER_SRC_MOLPRO_PROFILER_TREE_NODE_H