Node.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.h>
#include <imgui_node_editor.h>
#include <imgui_stdlib.h>
 
#include "internal/Node/Pin.hpp"
#include "Navigation/Time/InsTime.hpp"
 
#include "util/Logger.hpp"
 
#include <string>
#include <vector>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
#include <map>
 
#include <nlohmann/json.hpp>
using json = nlohmann::json; 
 
namespace NAV
{
class Node;
class NodeData;
class GroupBox;
 
namespace NodeRegistry
{
 
void RegisterNodeTypes(); // NOLINT(readability-redundant-declaration) - false warning. This is needed for the friend declaration below
 
} // namespace NodeRegistry
 
namespace FlowExecutor
{
 
void execute(); // NOLINT(readability-redundant-declaration) - false warning. This is needed for the friend declaration below
 
void deinitialize(); // NOLINT(readability-redundant-declaration) - false warning. This is needed for the friend declaration below
 
} // namespace FlowExecutor
 
namespace gui
{
class NodeEditorApplication;
 
namespace menus
{
 
void ShowRunMenu();
 
} // namespace menus
 
} // namespace gui
 
void to_json(json& j, const Node& node);
void from_json(const json& j, Node& node);
 
class Node
{
  public:
    struct Kind
    {
        enum Value : uint8_t
        {
            Blueprint, 
            Simple,    
            GroupBox,  
        };
 
        Kind() = default;
 
        constexpr Kind(Value kind) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
            : value(kind)
        {}
 
        explicit Kind(const std::string& string)
        {
            if (string == "Blueprint")
            {
                value = Kind::Blueprint;
            }
            else if (string == "Simple")
            {
                value = Kind::Simple;
            }
            else if (string == "GroupBox")
            {
                value = Kind::GroupBox;
            }
        }
 
        explicit operator Value() const { return value; }
        explicit operator bool() = delete;
        Kind& operator=(Value v)
        {
            value = v;
            return *this;
        }
 
        friend constexpr bool operator==(const Node::Kind& lhs, const Node::Kind& rhs);
        friend constexpr bool operator!=(const Node::Kind& lhs, const Node::Kind& rhs);
 
        friend constexpr bool operator==(const Node::Kind& lhs, const Node::Kind::Value& rhs);
        friend constexpr bool operator==(const Node::Kind::Value& lhs, const Node::Kind& rhs);
        friend constexpr bool operator!=(const Node::Kind& lhs, const Node::Kind::Value& rhs);
        friend constexpr bool operator!=(const Node::Kind::Value& lhs, const Node::Kind& rhs);
 
        explicit operator std::string() const
        {
            switch (value)
            {
            case Kind::Blueprint:
                return "Blueprint";
            case Kind::Simple:
                return "Simple";
            case Kind::GroupBox:
                return "GroupBox";
            }
            return "";
        }
 
      private:
        Value value;
    };
 
    enum class State : uint8_t
    {
        Disabled,       
        Deinitialized,  
        DoInitialize,   
        Initializing,   
        Initialized,    
        DoDeinitialize, 
        Deinitializing, 
        DoShutdown,     
        Shutdown,       
    };
 
    enum class Mode : uint8_t
    {
        REAL_TIME,       
        POST_PROCESSING, 
    };
 
    explicit Node(std::string name);
    virtual ~Node();
    Node(const Node&) = delete;
    Node(Node&&) = delete;
    Node& operator=(const Node&) = delete;
    Node& operator=(Node&&) = delete;
 
    /* -------------------------------------------------------------------------------------------------------- */
    /*                                                 Interface                                                */
    /* -------------------------------------------------------------------------------------------------------- */
 
    [[nodiscard]] virtual std::string type() const = 0;
 
    virtual void guiConfig();
 
    [[nodiscard]] virtual json save() const;
 
    virtual void restore(const json& j);
 
    virtual void restoreAtferLink(const json& j);
 
    virtual bool initialize();
 
    virtual void deinitialize();
 
    virtual bool resetNode();
 
    virtual bool onCreateLink(OutputPin& startPin, InputPin& endPin);
 
    virtual void onDeleteLink(OutputPin& startPin, InputPin& endPin);
 
    virtual void afterCreateLink(OutputPin& startPin, InputPin& endPin);
 
    virtual void afterDeleteLink(OutputPin& startPin, InputPin& endPin);
 
    virtual void flush();
 
    /* -------------------------------------------------------------------------------------------------------- */
    /*                                             Member functions                                             */
    /* -------------------------------------------------------------------------------------------------------- */
 
    void notifyOutputValueChanged(size_t pinIdx, const InsTime& insTime, const std::scoped_lock<std::mutex>& guard);
 
    [[nodiscard]] std::scoped_lock<std::mutex> requestOutputValueLock(size_t pinIdx);
 
    template<typename T>
    [[nodiscard]] std::optional<InputPin::IncomingLink::ValueWrapper<T>> getInputValue(size_t portIndex) const
    {
        return inputPins.at(portIndex).link.getValue<T>();
    }
 
    void releaseInputValue(size_t portIndex);
 
    void invokeCallbacks(size_t portIndex, const std::shared_ptr<const NodeData>& data);
 
    [[nodiscard]] InputPin& inputPinFromId(ax::NodeEditor::PinId pinId);
 
    [[nodiscard]] OutputPin& outputPinFromId(ax::NodeEditor::PinId pinId);
 
    [[nodiscard]] size_t inputPinIndexFromId(ax::NodeEditor::PinId pinId) const;
 
    [[nodiscard]] size_t outputPinIndexFromId(ax::NodeEditor::PinId pinId) const;
 
    [[nodiscard]] std::string nameId() const;
 
    [[nodiscard]] const ImVec2& getSize() const;
 
    // ------------------------------------------ State handling ---------------------------------------------
 
    static std::string toString(State state);
 
    [[nodiscard]] State getState() const;
 
    [[nodiscard]] Mode getMode() const;
 
    bool doInitialize(bool wait = false);
 
    bool doReinitialize(bool wait = false);
 
    bool doDeinitialize(bool wait = false);
 
    bool doDisable(bool wait = false);
 
    bool doEnable();
 
    void wakeWorker();
 
    [[nodiscard]] bool isDisabled() const;
 
    [[nodiscard]] bool isInitialized() const;
 
    [[nodiscard]] bool isTransient() const;
 
    [[nodiscard]] bool isOnlyRealtime() const;
 
    /* -------------------------------------------------------------------------------------------------------- */
    /*                                             Member variables                                             */
    /* -------------------------------------------------------------------------------------------------------- */
 
    ax::NodeEditor::NodeId id = 0;
    Kind kind = Kind::Blueprint;
    std::string name;
    std::vector<InputPin> inputPins;
    std::vector<OutputPin> outputPins;
 
    bool callbacksEnabled = false;
 
    std::multimap<InsTime, std::pair<OutputPin*, size_t>> pollEvents;
 
  protected:
    ImVec2 _guiConfigDefaultWindowSize{ 500.0F, 400.0F };
 
    bool _hasConfig = false;
 
    bool _lockConfigDuringRun = true;
 
    bool _onlyRealTime = false;
 
  private:
    State _state = State::Deinitialized; 
    mutable std::mutex _stateMutex;      
 
    std::atomic<Mode> _mode = Mode::REAL_TIME;
 
    bool _reinitialize = false;
 
    bool _disable = false;
 
    bool _showConfig = false;
 
    std::mutex _configWindowMutex;
    bool _configWindowForceCollapse = false;
    bool _configWindowIsCollapsed = false;
 
    bool _configWindowFocus = false;
 
    ImVec2 _size{ 0, 0 };
 
    static inline bool _autostartWorker = true;
 
    std::chrono::duration<int64_t> _workerTimeout = std::chrono::minutes(1); 
    std::thread _worker;                                                     
    std::mutex _workerMutex;                                                 
    std::condition_variable _workerConditionVariable;                        
    bool _workerWakeup = false;                                              
 
    static void workerThread(Node* node);
 
    virtual void workerTimeoutHandler();
 
    bool workerInitializeNode();
 
    bool workerDeinitializeNode();
 
    friend class gui::NodeEditorApplication;
    friend class NAV::GroupBox;
 
    friend void NAV::FlowExecutor::execute();
    friend void NAV::FlowExecutor::deinitialize();
    friend void NAV::NodeRegistry::RegisterNodeTypes();
 
    friend void NAV::to_json(json& j, const Node& node);
    friend void NAV::from_json(const json& j, Node& node);
 
    friend void gui::menus::ShowRunMenu();
};
 
constexpr bool operator==(const Node::Kind& lhs, const Node::Kind& rhs) { return lhs.value == rhs.value; }
constexpr bool operator!=(const Node::Kind& lhs, const Node::Kind& rhs) { return !(lhs == rhs); }
 
constexpr bool operator==(const Node::Kind& lhs, const Node::Kind::Value& rhs) { return lhs.value == rhs; }
constexpr bool operator==(const Node::Kind::Value& lhs, const Node::Kind& rhs) { return lhs == rhs.value; }
constexpr bool operator!=(const Node::Kind& lhs, const Node::Kind::Value& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const Node::Kind::Value& lhs, const Node::Kind& rhs) { return !(lhs == rhs); }
 
} // namespace NAV