Pin.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <imgui_node_editor.h>
 
#include <nlohmann/json.hpp>
using json = nlohmann::json; 
 
#include <string>
#include <variant>
#include <vector>
#include <memory>
#include <tuple>
#include <mutex>
#include <atomic>
#include <condition_variable>
 
#include "util/Logger.hpp"
#include "util/Container/TsDeque.hpp"
#include "Navigation/Time/InsTime.hpp"
 
namespace NAV
{
class Node;
class NodeData;
class InputPin;
class OutputPin;
 
class Pin
{
  public:
    struct Type
    {
        enum Value : uint8_t
        {
            None,     
            Flow,     
            Bool,     
            Int,      
            Float,    
            String,   
            Object,   
            Matrix,   
            Delegate, 
        };
 
        constexpr Type() = default;
 
        constexpr Type(Value type) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
            : value(type)
        {}
 
        explicit Type(const std::string& typeString)
        {
            if (typeString == "Flow")
            {
                value = Type::Flow;
            }
            else if (typeString == "Bool")
            {
                value = Type::Bool;
            }
            else if (typeString == "Int")
            {
                value = Type::Int;
            }
            else if (typeString == "Float")
            {
                value = Type::Float;
            }
            else if (typeString == "String")
            {
                value = Type::String;
            }
            else if (typeString == "Object")
            {
                value = Type::Object;
            }
            else if (typeString == "Matrix")
            {
                value = Type::Matrix;
            }
            else if (typeString == "Delegate")
            {
                value = Type::Delegate;
            }
        }
 
        explicit operator Value() const { return value; }
        explicit operator bool() = delete;
        Type& operator=(Value v)
        {
            value = v;
            return *this;
        }
 
        friend constexpr bool operator==(const Pin::Type& lhs, const Pin::Type& rhs);
        friend constexpr bool operator!=(const Pin::Type& lhs, const Pin::Type& rhs);
 
        friend constexpr bool operator==(const Pin::Type& lhs, const Pin::Type::Value& rhs);
        friend constexpr bool operator==(const Pin::Type::Value& lhs, const Pin::Type& rhs);
        friend constexpr bool operator!=(const Pin::Type& lhs, const Pin::Type::Value& rhs);
        friend constexpr bool operator!=(const Pin::Type::Value& lhs, const Pin::Type& rhs);
 
        explicit operator std::string() const
        {
            switch (value)
            {
            case Type::None:
                return "None";
            case Type::Flow:
                return "Flow";
            case Type::Bool:
                return "Bool";
            case Type::Int:
                return "Int";
            case Type::Float:
                return "Float";
            case Type::String:
                return "String";
            case Type::Object:
                return "Object";
            case Type::Matrix:
                return "Matrix";
            case Type::Delegate:
                return "Delegate";
            }
            return "";
        }
 
      private:
        Value value = Value::None;
    };
 
    struct Kind
    {
        enum Value : uint8_t
        {
            None,   
            Output, 
            Input,  
        };
 
        Kind() = default;
 
        constexpr Kind(Value kind) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
            : value(kind)
        {}
 
        explicit Kind(const std::string& kindString)
        {
            if (kindString == "Input")
            {
                value = Kind::Input;
            }
            else if (kindString == "Output")
            {
                value = Kind::Output;
            }
        }
 
        explicit operator Value() const { return value; }
        explicit operator bool() = delete;
        Kind& operator=(Value v)
        {
            value = v;
            return *this;
        }
 
        friend constexpr bool operator==(const Pin::Kind& lhs, const Pin::Kind& rhs);
        friend constexpr bool operator!=(const Pin::Kind& lhs, const Pin::Kind& rhs);
 
        friend constexpr bool operator==(const Pin::Kind& lhs, const Pin::Kind::Value& rhs);
        friend constexpr bool operator==(const Pin::Kind::Value& lhs, const Pin::Kind& rhs);
        friend constexpr bool operator!=(const Pin::Kind& lhs, const Pin::Kind::Value& rhs);
        friend constexpr bool operator!=(const Pin::Kind::Value& lhs, const Pin::Kind& rhs);
 
        explicit operator std::string() const
        {
            switch (value)
            {
            case Kind::None:
                return "None";
            case Kind::Input:
                return "Input";
            case Kind::Output:
                return "Output";
            }
        }
 
      private:
        Value value = Value::None;
    };
 
    struct Link
    {
        ax::NodeEditor::LinkId linkId = 0;        
        Node* connectedNode = nullptr;            
        ax::NodeEditor::PinId connectedPinId = 0; 
 
      protected:
        Link() = default;
 
        Link(ax::NodeEditor::LinkId linkId,
             Node* connectedNode,
             ax::NodeEditor::PinId connectedPinId)
            : linkId(linkId), connectedNode(connectedNode), connectedPinId(connectedPinId) {}
    };
 
    // /// Callback function type to call when firable
    // using OldFlowCallback = void (Node::*)(const std::shared_ptr<const NodeData>&, ax::NodeEditor::LinkId);
    // /// Notify function type to call when the connected value changed
    // using OldNotifyFunc = void (Node::*)(ax::NodeEditor::LinkId);
    // /// FileReader pollData function type
    // using OldPollDataFunc = std::shared_ptr<const NAV::NodeData> (Node::*)(bool);
 
    Pin(ax::NodeEditor::PinId id, const char* name, Type type, Kind kind, Node* parentNode)
        : id(id), name(name), type(type), kind(kind), parentNode(parentNode) {}
 
    [[nodiscard]] static bool canCreateLink(const OutputPin& startPin, const InputPin& endPin);
 
    [[nodiscard]] static bool dataIdentifierHaveCommon(const std::vector<std::string>& a, const std::vector<std::string>& b);
 
    [[nodiscard]] ImColor getIconColor() const;
 
    void drawPinIcon(bool connected, int alpha) const;
 
    ax::NodeEditor::PinId id;
    std::string name;
    Type type = Type::None;
    Kind kind = Kind::None;
    std::vector<std::string> dataIdentifier;
    Node* parentNode = nullptr;
 
  protected:
    Pin() = default;
 
    static bool createLink(OutputPin& startPin, InputPin& endPin, ax::NodeEditor::LinkId linkId = 0);
 
    static bool recreateLink(OutputPin& startPin, InputPin& endPin);
 
    static void deleteLink(OutputPin& startPin, InputPin& endPin);
 
  private:
    static constexpr int m_PinIconSize = 24;
};
 
class OutputPin : public Pin
{
  public:
    OutputPin(ax::NodeEditor::PinId id, const char* name, Type type, Node* parentNode)
        : Pin(id, name, type, Pin::Kind::Output, parentNode) {}
 
    OutputPin() = default;
    ~OutputPin() = default;
    OutputPin(const OutputPin&) = delete;
    OutputPin(OutputPin&& other) noexcept
        : Pin(std::move(other)),
          links(std::move(other.links)),                                                  // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          data(other.data),                                                               // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          noMoreDataAvailable(other.noMoreDataAvailable.load()),                          // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          blocksConnectedNodeFromFinishing(other.blocksConnectedNodeFromFinishing.load()) // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
    {}
    OutputPin& operator=(const OutputPin&) = delete;
    OutputPin& operator=(OutputPin&& other) noexcept
    {
        if (this != &other)
        {
            links = std::move(other.links);
            data = other.data;
            noMoreDataAvailable = other.noMoreDataAvailable.load();
            blocksConnectedNodeFromFinishing = other.blocksConnectedNodeFromFinishing.load();
            Pin::operator=(std::move(other));
        }
        return *this;
    }
 
    [[nodiscard]] bool canCreateLink(const InputPin& other) const;
 
    [[nodiscard]] bool isPinLinked() const;
 
    [[nodiscard]] bool isPinLinked(const InputPin& endPin) const;
 
    bool createLink(InputPin& endPin, ax::NodeEditor::LinkId linkId = 0);
 
    bool recreateLink(InputPin& endPin);
 
    void deleteLink(InputPin& endPin);
 
    void deleteLinks();
 
    struct OutgoingLink : public Link
    {
        OutgoingLink() = default;
 
        OutgoingLink(ax::NodeEditor::LinkId linkId,
                     Node* connectedNode,
                     ax::NodeEditor::PinId connectedPinId)
            : Link(linkId, connectedNode, connectedPinId) {}
 
        [[nodiscard]] InputPin* getConnectedPin() const;
 
        bool dataChangeNotification = false;
    };
 
    std::vector<OutgoingLink> links;
 
    using PeekPollDataFunc = std::shared_ptr<const NAV::NodeData> (Node::*)(size_t, bool);
 
    using PollDataFunc = std::shared_ptr<const NAV::NodeData> (Node::*)();
 
    using PinData = std::variant<const void*,        // Object/Matrix/Delegate
                                 const bool*,        // Bool
                                 const int*,         // Int
                                 const float*,       // Float
                                 const double*,      // Float
                                 const std::string*, // String
                                 PeekPollDataFunc,   // Flow (FileReader poll data function with peeking)
                                 PollDataFunc>;      // Flow (FileReader poll data function)
 
    PinData data = static_cast<void*>(nullptr);
 
    std::mutex dataAccessMutex;
 
    size_t dataAccessCounter = 0;
 
    std::condition_variable dataAccessConditionVariable;
 
    std::atomic<bool> noMoreDataAvailable = true;
 
    std::atomic<bool> blocksConnectedNodeFromFinishing = true;
 
    friend class Pin;
    friend class InputPin;
 
  private:
    void connect(InputPin& endPin, ax::NodeEditor::LinkId linkId = 0);
 
    void disconnect(InputPin& endPin);
};
 
class InputPin : public Pin
{
  public:
    InputPin(ax::NodeEditor::PinId id, const char* name, Type type, Node* parentNode)
        : Pin(id, name, type, Pin::Kind::Input, parentNode) {}
 
    InputPin() = default;
    ~InputPin() = default;
    InputPin(const InputPin&) = delete;
    InputPin(InputPin&& other) noexcept
        : Pin(std::move(other)),
          link(other.link),                                               // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          callback(other.callback),                                       // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          firable(other.firable),                                         // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          priority(other.priority),                                       // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          neededForTemporalQueueCheck(other.neededForTemporalQueueCheck), // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          dropQueueIfNotFirable(other.dropQueueIfNotFirable),             // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          queueBlocked(other.queueBlocked),                               // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
          queue(other.queue)                                              // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
    {}
    InputPin& operator=(const InputPin&) = delete;
    InputPin& operator=(InputPin&& other) noexcept
    {
        if (this != &other)
        {
            // copy if trivially-copyable, otherwise move
            link = other.link;
            callback = other.callback;
            firable = other.firable;
            priority = other.priority;
            neededForTemporalQueueCheck = other.neededForTemporalQueueCheck;
            dropQueueIfNotFirable = other.dropQueueIfNotFirable;
            queueBlocked = other.queueBlocked;
            queue = std::move(other.queue);
            Pin::operator=(std::move(other));
        }
        return *this;
    }
 
    [[nodiscard]] bool canCreateLink(const OutputPin& other) const;
 
    [[nodiscard]] bool isPinLinked() const;
 
    bool createLink(OutputPin& startPin, ax::NodeEditor::LinkId linkId = 0);
 
    bool recreateLink(OutputPin& startPin);
 
    void deleteLink();
 
    struct IncomingLink : public Link
    {
        IncomingLink() = default;
 
        IncomingLink(ax::NodeEditor::LinkId linkId,
                     Node* connectedNode,
                     ax::NodeEditor::PinId connectedPinId)
            : Link(linkId, connectedNode, connectedPinId) {}
 
        [[nodiscard]] OutputPin* getConnectedPin() const;
 
        template<typename T>
        class ValueWrapper
        {
          public:
            ValueWrapper(const T* v, OutputPin* outputPin, bool& dataChangeNotification)
                : v(v), outputPin(outputPin)
            {
                std::scoped_lock guard(outputPin->dataAccessMutex);
                if (!dataChangeNotification)
                {
                    outputPin->dataAccessCounter++;
                }
                dataChangeNotification = false; // We take 'ownership' of the incremented dataAccessCounter
            }
            ~ValueWrapper()
            {
                if (outputPin)
                {
                    std::scoped_lock guard(outputPin->dataAccessMutex);
                    if (outputPin->dataAccessCounter > 0)
                    {
                        outputPin->dataAccessCounter--;
                        if (outputPin->dataAccessCounter == 0)
                        {
                            outputPin->dataAccessConditionVariable.notify_all();
                        }
                    }
                }
            }
 
            ValueWrapper(const ValueWrapper& other)
                : v(other.v), outputPin(other.outputPin)
            {
                std::scoped_lock guard(outputPin->dataAccessMutex);
                outputPin->dataAccessCounter++;
            }
            ValueWrapper(ValueWrapper&& other) noexcept
                : v(std::move(other.v)), outputPin(other.outputPin)
            {
                other.outputPin = nullptr;
            }
            ValueWrapper& operator=(const ValueWrapper& other)
            {
                if (this != &other)
                {
                    v = other.v;
                    outputPin = other.outputPin;
                    std::scoped_lock guard(outputPin->dataAccessMutex);
                    outputPin->dataAccessCounter++;
                }
                return *this;
            }
            ValueWrapper& operator=(ValueWrapper&& other) noexcept
            {
                if (this != &other)
                {
                    v = std::move(other.v);
                    outputPin = other.outputPin;
                    other.outputPin = nullptr;
                }
                return *this;
            }
 
            const T* v;
 
          private:
            OutputPin* outputPin;
        };
 
        template<typename T>
        [[nodiscard]] std::optional<ValueWrapper<T>> getValue() const
        {
            if (auto* connectedPin = getConnectedPin())
            {
                // if (!connectedPin->parentNode->isInitialized()) { return nullptr; } // TODO: Check this here (Problem: member access into incomplete type 'NAV::Node')
 
                auto outgoingLink = std::ranges::find_if(connectedPin->links, [&](const OutputPin::OutgoingLink& link) {
                    return link.linkId == linkId;
                });
 
                // clang-format off
                if constexpr (std::is_same_v<T, bool>
                           || std::is_same_v<T, int>
                           || std::is_same_v<T, float>
                           || std::is_same_v<T, double>
                           || std::is_same_v<T, std::string>) // clang-format on
                {
                    if (const auto* pVal = std::get_if<const T*>(&(connectedPin->data));
                        pVal && *pVal)
                    {
                        return ValueWrapper<T>(*pVal, connectedPin, outgoingLink->dataChangeNotification);
                    }
                }
                else
                {
                    if (const auto* pVal = std::get_if<const void*>(&(connectedPin->data));
                        pVal && *pVal)
                    {
                        return ValueWrapper<T>(static_cast<const T*>(*pVal), connectedPin, outgoingLink->dataChangeNotification);
                    }
                }
            }
 
            return std::nullopt;
        }
    };
 
    IncomingLink link;
 
    using NodeDataQueue = TsDeque<std::shared_ptr<const NAV::NodeData>>;
 
    using FlowFirableCallbackFunc = void (Node::*)(NodeDataQueue&, size_t);
    using DataChangedNotifyFunc = void (Node::*)(const InsTime&, size_t);
    using Callback = std::variant<FlowFirableCallbackFunc, // Flow:  Callback function type to call when firable
                                  DataChangedNotifyFunc>;  // Other: Notify function type to call when the connected value changed
 
    Callback callback;
 
    using FlowFirableCheckFunc = bool (*)(const Node*, const InputPin&);
 
    FlowFirableCheckFunc firable = [](const Node*, const InputPin& inputPin) { return !inputPin.queue.empty() && !inputPin.queueBlocked; };
 
    int priority = 0;
 
    bool neededForTemporalQueueCheck = true;
 
    bool dropQueueIfNotFirable = true;
 
    bool queueBlocked = false;
 
    NodeDataQueue queue;
 
#ifdef TESTING
    using FlowFirableWatcherCallbackFunc = std::function<void(const Node*, const NodeDataQueue&, size_t)>;
    using DataChangedWatcherNotifyFunc = std::function<void(const Node*, const InsTime&, size_t)>;
 
    using WatcherCallback = std::variant<FlowFirableWatcherCallbackFunc, // Flow:  Callback function type to call when firable
                                         DataChangedWatcherNotifyFunc>;  // Other: Notify function type to call when the connected value changed
 
    std::vector<WatcherCallback> watcherCallbacks;
#endif
 
    friend class Pin;
    friend class OutputPin;
 
  private:
    void connect(OutputPin& startPin, ax::NodeEditor::LinkId linkId = 0);
 
    void disconnect();
};
 
constexpr bool operator==(const Pin::Kind& lhs, const Pin::Kind& rhs) { return lhs.value == rhs.value; }
constexpr bool operator!=(const Pin::Kind& lhs, const Pin::Kind& rhs) { return !(lhs == rhs); }
 
constexpr bool operator==(const Pin::Kind& lhs, const Pin::Kind::Value& rhs) { return lhs.value == rhs; }
constexpr bool operator==(const Pin::Kind::Value& lhs, const Pin::Kind& rhs) { return lhs == rhs.value; }
constexpr bool operator!=(const Pin::Kind& lhs, const Pin::Kind::Value& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const Pin::Kind::Value& lhs, const Pin::Kind& rhs) { return !(lhs == rhs); }
 
constexpr bool operator==(const Pin::Type& lhs, const Pin::Type& rhs) { return lhs.value == rhs.value; }
constexpr bool operator!=(const Pin::Type& lhs, const Pin::Type& rhs) { return !(lhs == rhs); }
 
constexpr bool operator==(const Pin::Type& lhs, const Pin::Type::Value& rhs) { return lhs.value == rhs; }
constexpr bool operator==(const Pin::Type::Value& lhs, const Pin::Type& rhs) { return lhs == rhs.value; }
constexpr bool operator!=(const Pin::Type& lhs, const Pin::Type::Value& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const Pin::Type::Value& lhs, const Pin::Type& rhs) { return !(lhs == rhs); }
 
void to_json(json& j, const OutputPin& pin);
void from_json(const json& j, OutputPin& pin);
 
void to_json(json& j, const InputPin& pin);
void from_json(const json& j, InputPin& pin);
 
} // namespace NAV