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(OpId target) const;
 
    std::optional<Connection> getInputConnection(OpId target, unsigned int inputSlot) const;
 
    std::vector<Connection> getOutputs(OpId source) const;
 
    void setCapturedDependencies(const Unit& dependent, const std::vector<Unit>& dependencies);
 
    void removeNode(OpId opId);
 
    void clear();
 
    std::vector<OpId> getCookOrder(OpId target) const;
 
    std::vector<Unit> getDependents(const Unit& changed) const;
 
  private:
    using ConnectionMap = std::unordered_map<OpId, std::vector<Connection>>;
    using CapturedMap = std::unordered_map<Unit, std::vector<Unit>>;
 
    static void eraseConnection_(ConnectionMap& side, OpId key, const Connection& connection);
 
    static void eraseConnectionsTouching_(ConnectionMap& side, OpId opId);
 
    static void eraseCapturedTouching_(CapturedMap& map, OpId opId);
 
    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_(
        OpId opId,
        std::vector<OpId>& opOrder,
        std::unordered_set<OpId>& addedOps,
        std::unordered_set<OpId>& opsBeingAdded
    ) 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_;
};
 
} // namespace enzo::nt