NetworkGraph.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/NetworkGraph/Connection.h"
#include "Engine/NetworkGraph/Unit.h"
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace enzo::nt {
 
class NetworkGraph
{
  public:
    void connect(const Connection& connection);
 
    void disconnect(const Connection& connection);
 
    std::vector<Connection> getInputs(NodeId target) const;
 
    std::optional<Connection> getInputConnection(NodeId target, unsigned int inputIndex) const;
 
    std::vector<Connection> getOutputs(NodeId source) const;
 
    std::vector<Connection> getConnections() const;
 
    void setCapturedDependencies(const Unit& dependent, const std::vector<Unit>& dependencies);
 
    void setTimeDependent(const Unit& dependent, bool dependsOnTime);
 
    std::vector<Unit> getTimeDependents() const;
 
    void removeNode(NodeId nodeId);
 
    void clear();
 
    std::vector<NodeId> getCookOrder(NodeId target) const;
 
    std::vector<Unit> getDependents(const Unit& changed) const;
 
  private:
    using ConnectionMap = std::unordered_map<NodeId, std::vector<Connection>>;
    using CapturedMap = std::unordered_map<Unit, std::vector<Unit>>;
 
    static void eraseConnection_(ConnectionMap& side, NodeId key, const Connection& connection);
 
    static void eraseConnectionsTouching_(ConnectionMap& side, NodeId nodeId);
 
    static void eraseCapturedTouching_(CapturedMap& map, NodeId nodeId);
 
    static void eraseUnit_(CapturedMap& map, const Unit& key, const Unit& value);
 
    static void addDependent_(
        const Unit& unit,
        std::vector<Unit>& dependents,
        std::unordered_set<Unit>& seen,
        std::vector<Unit>& pending
    );
 
    void addToCookOrder_(
        NodeId nodeId,
        std::vector<NodeId>& nodeOrder,
        std::unordered_set<NodeId>& addedNodes,
        std::unordered_set<NodeId>& nodesBeingAdded
    ) const;
 
    // Input connections keyed by the downstream node.
    ConnectionMap byTarget_;
    // Output connections keyed by the upstream node.
    ConnectionMap bySource_;
    // Captured edges are mixed granularity. The source is stored at node level
    // since dirtying is node wide, while the reader is stored per parameter
    // component so re-evaluating one component leaves the others intact.
    // getDependents collapses the reader back to its node to bridge the two.
 
    // Captured readers keyed by the node they read.
    CapturedMap capturedDependents_;
    // Captured reads keyed by the reading parameter component.
    CapturedMap capturedDependencies_;
 
    // The units that read the scene time, at the same mixed granularity as the
    // captured maps.
    std::unordered_set<Unit> timeDependents_;
};
 
} // namespace enzo::nt