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
 
// <boost/asio.hpp> needs to be included before <winsock.h> (even though not used in this file)
// https://stackoverflow.com/questions/9750344/boostasio-winsock-and-winsock-2-compatibility-issue
#ifdef _WIN32
    // Set the proper SDK version before including boost/Asio
    #include <SDKDDKVer.h>
    // Note boost/ASIO includes Windows.h.
    #include <boost/asio.hpp>
#endif //_WIN32
 
#include <imgui.h>
#include <imgui_node_editor.h>
#include <imgui_stdlib.h>
 
#include "internal/Node/Pin.hpp"
#include "Navigation/Time/InsTime.hpp"
 
#include <string>
#include <vector>
#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);

    bool hasInputPinWithSameTime(const InsTime& insTime) const;

    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