Controller.hpp

// SPDX-FileCopyrightText: 2025 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <unordered_map>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Project includes
#include "NodeFactory.hpp"
#include <dfx-hooks/Graph.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
#include <dfx-utilities/RecyclableIdAllocator.hpp>

 
namespace dfx::Graph
{
class Controller
{
public:
    Controller() = default;
    ~Controller();
    ENABLE_DEFAULT_MOVE_DISABLE_COPY(Controller);

    Core::Node::Id addNode(std::string_view type, std::string_view name,
                           nlohmann::json config = {});

    Core::Node::Id addNode(Core::Node::Id id,
                           std::string_view type, std::string_view name,
                           nlohmann::json config = {});

    bool removeNode(Core::Node::Id id);

    bool removeNode(std::string_view name);

    bool hasNode(Core::Node::Id id) const;
    bool hasNode(std::string_view name) const;
    bool hasNodeType(std::string_view type) const;

    std::vector<std::string> allNodeType() const;
    std::vector<std::string> allNodeName() const;
    std::vector<Core::Node::Id> allNodeId() const;

    Core::NodePtr node(Core::Node::Id id) const;
    Core::NodePtr node(std::string_view name) const;
    std::vector<Core::NodePtr> nodes() const;

    Core::Channel::Id addChannel(Core::OutputPort & src, Core::InputPort & dst,
                                 std::vector<std::string> * errors = nullptr,
                                 std::size_t errorLimit = 0);

    bool removeChannel(Core::Channel::Id id);

    bool hasChannel(Core::Channel::Id id) const;
    std::vector<Core::Channel::Id> allChannelId() const;

    Core::ChannelPtr channel(Core::Channel::Id id) const;

    std::vector<Core::ChannelPtr> channels() const;

    NodeFactory & nodeFactory() noexcept             { return _factory; }

    NodeFactory const & nodeFactory() const noexcept { return _factory; }
 
public:
    bool isChannelVerificationEnabled() const noexcept { return _channelVerificationEnabled; }
    void setChannelVerification(bool enabled)          { _channelVerificationEnabled = enabled; }
 
public:
    void registerHook(Hooks::Graph * hook);

    void deregisterHook(Hooks::Graph * hook);
 
private:
    bool _validateChannelConnection(Core::OutputPort const & src, Core::InputPort const & dst,
                                    std::vector<std::string> * errors = nullptr,
                                    std::size_t errorLimit = 0) const;
 
    void _addNode(Core::Node::Id nodeId, std::string_view type, std::string_view name,
                  nlohmann::json config);
    void _removeNode(std::unordered_map<Core::Node::Id, Core::NodePtr>::iterator itr);
 
private:
    NodeFactory _factory;
 
    std::unordered_map<Core::Node::Id, Core::NodePtr>       _nodes;
    std::unordered_map<Core::Channel::Id, Core::ChannelPtr> _channels;
 
    Utils::RecyclableIdAllocator<Core::Node::Id>    _nodeIdAllocator;
    Utils::RecyclableIdAllocator<Core::Channel::Id> _channelIdAllocator;
 
    bool _channelVerificationEnabled = true;
 
private:
    std::vector<Hooks::Graph *> _hooks;
};
} // !namespace dfx::Graph