Ports.hpp

Go to the documentation of this file.

#pragma once
 
#include <exception>
#include <functional>
#include <tuple>
#include <unordered_map>
#include <vector>
 
#include "smgl/Metadata.hpp"
#include "smgl/Uuid.hpp"
 
namespace smgl
{
 
struct bad_connection : public std::exception {
public:
    explicit bad_connection(const char* msg) : msg_(msg) {}
    explicit bad_connection(std::string msg) : msg_(std::move(msg)) {}
    const char* what() const noexcept override { return msg_.c_str(); }
 
protected:
    std::string msg_;
};
 
template <typename T>
struct Update {
    T val;
    std::size_t tick{0};
};
 
class Input;
class Output;
template <typename T>
class InputPort;
template <typename T, typename... Args>
class OutputPort;
class Node;
void connect(Output& op, Input& ip);
 
void disconnect(Output& op, Input& ip);
 
void operator>>(Output& op, Input& ip);
void operator<<(Input& ip, Output& op);
 
struct Connection {
    Connection() = default;
    Connection(Node* s, Output* sp, Node* d, Input* dp)
        : srcNode{s}, srcPort{sp}, destNode{d}, destPort{dp}
    {
    }
    Node* srcNode{nullptr};
    Output* srcPort{nullptr};
    Node* destNode{nullptr};
    Input* destPort{nullptr};
};
 
class Port : public UniquelyIdentifiable
{
public:
    enum class State { Idle, Waiting, Queued, Error };
 
    virtual bool update() = 0;
 
    virtual void notify(State s) = 0;
 
    State state() const;
 
    void setState(State s);
 
    void setParent(Node* p);
 
    virtual Metadata serialize() = 0;
 
    virtual void deserialize(const Metadata& m) = 0;
 
protected:
    Port() = default;
    explicit Port(State s);
    virtual ~Port() = default;
    State state_{State::Idle};
    Node* parent_{nullptr};
};
 
class Input : public Port
{
public:
    std::vector<Connection> getConnections() const;
 
    std::size_t numConnections() const;
 
    virtual Input& operator=(Output& op);
 
protected:
    Input();
    ~Input() override;
 
    virtual void connect(Output* op) final;
    virtual void disconnect(Output* op) final;
 
    Output* src_{nullptr};
    std::size_t last_updated_{0};
 
private:
    friend void connect(Output& op, Input& ip);
    friend void disconnect(Output& op, Input& ip);
    template <typename OutputValType, typename... OutputArgs>
    friend class OutputPort;
};
 
class Output : public Port
{
public:
    virtual std::vector<Connection> getConnections() const = 0;
    virtual std::size_t numConnections() const = 0;
 
protected:
    Output();
    ~Output() override = default;
 
    virtual void connect(Input* ip) = 0;
    virtual void disconnect(Input* ip) = 0;
 
private:
    friend void connect(Output& op, Input& ip);
    friend void disconnect(Output& op, Input& ip);
    friend Input;
};
 
template <typename T>
class InputPort : public Input
{
public:
    ~InputPort() override = default;
 
    explicit InputPort(T* target);
 
    explicit InputPort(std::function<void(T)> target);
 
    template <class Obj, class ObjMemberFn>
    explicit InputPort(Obj* obj, ObjMemberFn&& fn);
 
    InputPort(const InputPort&) = delete;
    InputPort& operator=(const InputPort&) = delete;
    InputPort(const InputPort&&) = delete;
    InputPort& operator=(const InputPort&&) = delete;
 
    void post(const Update<T>& u);
 
    void post(T v, bool immediate = false);
 
    void operator()(const Update<T>& u);
 
    void operator()(T v, bool immediate = false);
 
    InputPort<T>& operator=(T v);
 
    InputPort<T>& operator=(Output& op) override;
 
    bool update() override;
 
    void notify(State s) override;
 
    Metadata serialize() override;
 
    void deserialize(const Metadata& m) override;
 
private:
    std::function<void(T)> target_;
    Update<T> queued_update_;
};
 
template <typename T, typename... Args>
class OutputPort : public Output
{
public:
    using Arguments = std::tuple<Args...>;
 
    ~OutputPort() override;
 
    explicit OutputPort(T source);
 
    explicit OutputPort(T* source);
 
    explicit OutputPort(std::function<T(Args...)> source, Args&&... args);
 
    template <class Obj, class ObjMemberFn>
    explicit OutputPort(Obj* obj, ObjMemberFn&& fn, Args&&... args);
 
    OutputPort(const OutputPort&) = delete;
    OutputPort& operator=(const OutputPort&) = delete;
    OutputPort(const OutputPort&&) = delete;
    OutputPort& operator=(const OutputPort&&) = delete;
 
    std::vector<Connection> getConnections() const override;
 
    std::size_t numConnections() const override;
 
    void setArgs(Args&&... args);
 
    T val();
    T operator()();
 
    bool update() override;
 
    void notify(State s) override;
 
    Metadata serialize() override;
 
    void deserialize(const Metadata& m) override;
 
private:
    std::function<T(Args...)> source_;
 
    Arguments args_;
 
    template <std::size_t... Is>
    T run_(std::tuple<Args...>& tup, std::index_sequence<Is...>);
 
    T run_(std::tuple<Args...>& tup);
 
    void connect(Input* ip) final;
 
    void disconnect(Input* ip) final;
 
    struct TypedConnection {
        Node* node;
        InputPort<T>* port;
    };
 
    std::unordered_map<Uuid, TypedConnection> connections_;
};
 
}  // namespace smgl
 
#include "smgl/PortsImpl.hpp"