NetworkManager.h

#pragma once
#include "Engine/Network/UpdateLock.h"
#include "Engine/Operator/GeometryOperator.h"
#include "Engine/UndoRedo/UndoStack.h"
#include "Engine/Types.h"
#include <memory>
#include <unordered_map>
#include <QObject>
 
namespace enzo::nt {
class NetworkManager
: public QObject
{
    // TODO: make not Q_OBJECT
    Q_OBJECT
public:
 
    class OperatorRange {
        using Map = std::unordered_map<OpId, std::unique_ptr<GeometryOperator>>;
        Map& map_;
    public:
        class Iterator {
            Map::iterator it_;
        public:
            using value_type = std::pair<const OpId, GeometryOperator&>;
            using reference = value_type;
            using difference_type = std::ptrdiff_t;
            using iterator_category = std::forward_iterator_tag;
 
            Iterator(Map::iterator it) : it_(it) {}
            reference operator*() const { return {it_->first, *it_->second}; }
            Iterator& operator++() { ++it_; return *this; }
            Iterator operator++(int) { Iterator tmp = *this; ++it_; return tmp; }
            bool operator==(const Iterator& other) const { return it_ == other.it_; }
            bool operator!=(const Iterator& other) const { return it_ != other.it_; }
        };
 
        OperatorRange(Map& map) : map_(map) {}
        Iterator begin() { return Iterator(map_.begin()); }
        Iterator end() { return Iterator(map_.end()); }
        std::size_t size() const { return map_.size(); }
    };
 
    OperatorRange operators() { return OperatorRange(gopStore_); }
 
    NetworkManager(const NetworkManager& obj) = delete;
 
    static NetworkManager& getInstance();
 
    OpId createOperator(op::OpInfo opInfo, bt::Vector2f position = {0.f, 0.f});
 
    std::optional<OpId> getDisplayOp();
 
    enzo::nt::UpdateLock lockUpdates();
 
    void update();
 
    bool isValidOp(nt::OpId opId);
 
    GeometryOperator& getGeoOperator(nt::OpId opId);
 
    void setDisplayOp(OpId opId);
 
    void clearDisplayFlag();
 
    void setSelectedNode(OpId opId, bool selected, bool add=false);
 
    const std::vector<enzo::nt::OpId>& getSelectedNodes();
 
    void setSelectedNodes(std::vector<enzo::nt::OpId> opIds);
 
    void moveNode(OpId opId, bt::Vector2f newPos, bool skipUndo=false);
 
    void deleteNode(OpId opId);
 
    void removeOperator(OpId opId);
 
    void restoreOperator(OpId opId, op::OpInfo opInfo);
 
    void clear();
 
    void cookOp(enzo::nt::OpId opId);
 
    // @brief A signal emitted when the display node is changed
    boost::signals2::signal<void (std::optional<nt::OpId>)> displayNodeChanged;
 
    // @brief A signal emitted when the geometry to be displayed is changed
    // This is different to #displayNodeChanged because the state of geometry
    // in a node can change based on parameters or other factors.
    boost::signals2::signal<void (std::shared_ptr<const enzo::NodePacket>)> displayGeoChanged;
 
    // @brief A signal emitted when the selected node's geometry is changed
    boost::signals2::signal<void (std::shared_ptr<const enzo::NodePacket>)> selectedGeoChanged;
 
    // @brief A signal emitted when the selection of nodes changes
    boost::signals2::signal<void (std::vector<nt::OpId> selectedNodeIds)> selectedNodesChanged;
 
    // @brief A signal emitted when a new operator is created in the network
    boost::signals2::signal<void (nt::OpId)> operatorCreated;
 
    // @brief A signal emitted when an operator is about to be removed from the network
    boost::signals2::signal<void (nt::OpId)> operatorRemoved;
 
    // @brief A signal emitted when a connection is created between two operators
    boost::signals2::signal<void (std::weak_ptr<nt::GeometryConnection>)> connectionCreated;
 
    // @brief A signal emitted when the network is cleared
    boost::signals2::signal<void ()> networkCleared;
 
    // @brief A signal emitted when a node's position changes programmatically (e.g. undo/redo)
    boost::signals2::signal<void (nt::OpId, bt::Vector2f)> nodePositionChanged;
    UndoStack& undoStack() { return undoStack_; }
 
    #ifdef UNIT_TEST
        void _reset();
    #endif
 
private:
    NetworkManager() {};
 
    // functions
    std::vector<enzo::nt::OpId> getDependencyGraph(enzo::nt::OpId opId);
    std::vector<enzo::nt::OpId> getDependentsGraph(enzo::nt::OpId opId);
 
    void onNodeDirtied(nt::OpId opId, bool dirtyDependents);
 
    // variables
    // store for geometry operators
    std::vector<enzo::nt::OpId> selectedNodes_;
    std::unordered_map<enzo::nt::OpId, std::unique_ptr<enzo::nt::GeometryOperator>> gopStore_;
    // the highest operator id currently stored
    enzo::nt::OpId maxOpId_=0;
    // operator selected for displaying in the viewport
    std::optional<OpId> displayOp_=std::nullopt;
 
    UndoStack undoStack_;
 
};
 
inline enzo::nt::NetworkManager& nm() {
    return enzo::nt::NetworkManager::getInstance();
}
}