Network.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/Network/NetworkPath.h"
#include "Engine/Network/Node.h"
#include "Engine/Network/Scope.h"
#include "Engine/NetworkGraph/NetworkGraph.h"
#include <memory>
#include <ranges>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace enzo::nt {
class Network
{
  public:
    using NodeStore = std::unordered_map<NodeId, std::unique_ptr<Node>>;
 
    Network() { clear(); }
 
    Network(const Network&) = delete;
    Network& operator=(const Network&) = delete;
 
    auto nodes()
    {
        return std::views::transform(nodes_, [](NodeStore::value_type& entry) {
            return std::pair<const NodeId, Node&>(entry.first, *entry.second);
        });
    }
 
    Node& getNode(NodeId nodeId);
 
    bool isValidNode(NodeId nodeId) const;
 
    Node* getNodeAtPath(const Path& path);
 
    std::vector<NodeId> getChildNodeIds(const Path& scope);
 
    Node& createNode(NodeId nodeId, const NodeType& nodeType, const Path& path);
 
    void deleteNode(NodeId nodeId);
 
    NodeId reserveNodeId() { return ++maxNodeId_; }
 
    Node* findNode(const NetworkPath& path, NodeId fromNode = nullNode);
 
    std::weak_ptr<prm::NodeParameter>
    findParameter(const NetworkPath& path, NodeId fromNode = nullNode);
    Scope* getScope(const Path& path);
 
    NetworkGraph& graph() { return graph_; }
 
    void clear();
 
  private:
    // A scope exists only because a node holds it, so it opens and closes with that node
    void createScope(const Path& path, const std::string& scopeType);
    void deleteScope(const Path& path);
 
    // Every node, flat, with nesting carried in their paths
    NodeStore nodes_;
    NetworkGraph graph_;
    // Every scope that exists, keyed by the path it sits at, always holding the root
    std::unordered_map<std::string, Scope> scopes_;
    // The highest node id handed out so far
    NodeId maxNodeId_ = 0;
};
} // namespace enzo::nt