Node.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
#include "smgl/Factory.hpp"
#include "smgl/Metadata.hpp"
#include "smgl/Ports.hpp"
#include "smgl/Singleton.hpp"
#include "smgl/Uuid.hpp"
#include "smgl/filesystem.hpp"
 
namespace smgl
{
 
class Node : public UniquelyIdentifiable
{
public:
    enum class State {
        Idle,
        Waiting,
        Ready,
        Updating,
        Error
    };
 
    using Pointer = std::shared_ptr<Node>;
 
    struct Info {
        Info(std::string n, const Uuid& u) : name{std::move(n)}, uuid{u} {}
        std::string name;
        Uuid uuid;
    };
 
    void update();
 
    auto serialize(bool useCache, const filesystem::path& cacheRoot)
        -> Metadata;
 
    void deserialize(const Metadata& meta, const filesystem::path& cacheRoot);
 
    auto getInputPortsInfo() const -> std::vector<Info>;
 
    auto getOutputPortsInfo() const -> std::vector<Info>;
 
    auto getInputPort(const Uuid& uuid) -> Input&;
    auto getInputPort(const std::string& name) -> Input&;
 
    auto getOutputPort(const Uuid& uuid) -> Output&;
    auto getOutputPort(const std::string& name) -> Output&;
 
    auto getInputConnections() const -> std::vector<Connection>;
 
    auto getNumberOfInputConnections() const -> size_t;
 
    auto getOutputConnections() const -> std::vector<Connection>;
 
    auto getNumberOfOutputConnections() const -> size_t;
 
    auto state() -> State;
 
protected:
    Node();
    explicit Node(bool usesCacheDir);
    virtual ~Node() = default;
 
    template <typename T>
    void registerInputPort(const std::string& name, InputPort<T>& port);
 
    template <typename T>
    void registerPort(const std::string& name, InputPort<T>& port);
 
    template <typename T, typename... Args>
    void registerOutputPort(
        const std::string& name, OutputPort<T, Args...>& port);
 
    template <typename T, typename... Args>
    void registerPort(const std::string& name, OutputPort<T, Args...>& port);
 
    std::function<void()> compute;
 
    std::function<bool()> usesCacheDir;
 
private:
    virtual auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> Metadata;
 
    // clang-format off
    // clang-format on
    virtual void deserialize_(
        const Metadata& data, const filesystem::path& cacheDir);
 
    auto update_input_ports_() -> bool;
 
    void notify_output_ports_(Port::State s);
 
    auto update_output_ports_() -> bool;
 
    template <class PortType>
    static void LoadAndRegisterPort(
        const std::string& name,
        const Metadata& data,
        std::unordered_map<Uuid, PortType*>& byUuid,
        std::map<std::string, PortType*>& byName);
 
    std::unordered_map<Uuid, Input*> inputs_by_uuid_;
    std::map<std::string, Input*> inputs_by_name_;
    std::unordered_map<Uuid, Output*> outputs_by_uuid_;
    std::map<std::string, Output*> outputs_by_name_;
    State state_{State::Idle};
};
 
namespace detail
{
using NodeFactoryType =
    SingletonHolder<Factory<Node, std::string, Node::Pointer>>;
}  // namespace detail
 
using unknown_identifier =
    detail::NodeFactoryType::InstanceType::unknown_identifier;
 
template <class T>
struct NodeDesc {
    explicit NodeDesc(std::string k) : key{std::move(k)} {}
    std::string key;
};
 
template <class... Ts>
auto RegisterNodes(const NodeDesc<Ts>&... descs) -> bool;
 
template <class T>
auto RegisterNode(const std::string& name) -> bool;
 
template <class T, class... Ts>
auto DeregisterNode() -> bool;
 
template <class... Ts>
auto DeregisterNodes(const NodeDesc<Ts>&... descs) -> bool;
 
auto DeregisterNode(const std::string& name) -> bool;
 
auto CreateNode(const std::string& name) -> Node::Pointer;
 
template <class T>
auto NodeName() -> std::string;
 
auto NodeName(const Node::Pointer& node) -> std::string;
 
auto NodeName(const Node* node) -> std::string;
 
auto IsRegistered(const std::string& name) -> bool;
 
auto IsRegistered(const Node::Pointer& node) -> bool;
 
auto IsRegistered(const Node* node) -> bool;
 
}  // namespace smgl
 
#define SMGL_NODE(...) ::smgl::NodeDesc<__VA_ARGS__>(#__VA_ARGS__)
 
#include "smgl/NodeImpl.hpp"