NodeManager.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 "internal/Node/Node.hpp"
#include "internal/Node/Pin.hpp"
#include "util/Assert.h"
 
#include "NodeData/NodeData.hpp"
 
#include <vector>
#include <functional>
 
namespace NAV::NodeManager
{
extern bool showFlowWhenInvokingCallbacks;
 
extern bool showFlowWhenNotifyingValueChange;
 
const std::vector<Node*>& m_Nodes();
 
void AddNode(Node* node);
 
void UpdateNode(Node* node);
 
bool DeleteNode(ax::NodeEditor::NodeId nodeId);
 
void DeleteAllNodes();
 
void AddLink(ax::NodeEditor::LinkId linkId);
 
InputPin* CreateInputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier = {},
                         InputPin::Callback callback = static_cast<InputPin::FlowFirableCallbackFunc>(nullptr),
                         InputPin::FlowFirableCheckFunc firable = nullptr,
                         int priority = 0, int idx = -1);
 
template<typename T,
         typename = std::enable_if_t<std::is_base_of_v<Node, T>>>
InputPin* CreateInputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier = {},
                         void (T::*callback)(InputPin::NodeDataQueue&, size_t) = nullptr,
                         InputPin::FlowFirableCheckFunc firable = nullptr,
                         int priority = 0, int idx = -1)
{
    assert(pinType == Pin::Type::Flow);
 
    return CreateInputPin(node, name, pinType, dataIdentifier, InputPin::Callback(static_cast<InputPin::FlowFirableCallbackFunc>(callback)), firable, priority, idx);
}
 
template<typename T,
         typename = std::enable_if_t<std::is_base_of_v<Node, T>>>
InputPin* CreateInputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier,
                         void (T::*notifyFunc)(const InsTime&, size_t), int idx = -1)
{
    assert(pinType != Pin::Type::Flow && pinType != Pin::Type::Delegate);
 
    return CreateInputPin(node, name, pinType, dataIdentifier, InputPin::Callback(static_cast<InputPin::DataChangedNotifyFunc>(notifyFunc)), nullptr, 0, idx);
}
 
OutputPin* CreateOutputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier, OutputPin::PinData data = static_cast<void*>(nullptr), int idx = -1);
 
template<typename T,
         typename = std::enable_if_t<std::is_base_of_v<Node, T>>>
OutputPin* CreateOutputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier,
                           std::shared_ptr<const NAV::NodeData> (T::*peekPollDataFunc)(size_t, bool) = nullptr, int idx = -1)
{
    assert(pinType == Pin::Type::Flow);
    INS_ASSERT_USER_ERROR(std::none_of(node->outputPins.begin(), node->outputPins.end(),
                                       [](const OutputPin& outputPin) { return std::holds_alternative<OutputPin::PollDataFunc>(outputPin.data); }),
                          "You cannot mix PollDataFunc and PeekPollDataFunc output pins. Use only PeekPollDataFunc pins if multiple pins are needed.");
 
    return CreateOutputPin(node, name, pinType, dataIdentifier, OutputPin::PinData(static_cast<OutputPin::PeekPollDataFunc>(peekPollDataFunc)), idx);
}
 
template<typename T,
         typename = std::enable_if_t<std::is_base_of_v<Node, T>>>
OutputPin* CreateOutputPin(Node* node, const char* name, Pin::Type pinType, const std::vector<std::string>& dataIdentifier,
                           std::shared_ptr<const NAV::NodeData> (T::*pollDataFunc)() = nullptr, int idx = -1)
{
    assert(pinType == Pin::Type::Flow);
    INS_ASSERT_USER_ERROR(std::none_of(node->outputPins.begin(), node->outputPins.end(),
                                       [](const OutputPin& outputPin) { return std::holds_alternative<OutputPin::PeekPollDataFunc>(outputPin.data)
                                                                               || std::holds_alternative<OutputPin::PollDataFunc>(outputPin.data); }),
                          "There can only be one poll pin if the poll only data function is chosen. If multiple are needed, create PeekPollDataFunc pins.");
 
    return CreateOutputPin(node, name, pinType, dataIdentifier, OutputPin::PinData(static_cast<OutputPin::PollDataFunc>(pollDataFunc)), idx);
}
 
bool DeleteOutputPin(OutputPin& pin);
 
bool DeleteInputPin(InputPin& pin);
 
Node* FindNode(ax::NodeEditor::NodeId id);
 
OutputPin* FindOutputPin(ax::NodeEditor::PinId id);
 
InputPin* FindInputPin(ax::NodeEditor::PinId id);
 
void EnableAllCallbacks();
 
void DisableAllCallbacks();
 
void ClearAllNodeQueues();
 
bool InitializeAllNodes();
 
void InitializeAllNodesAsync();
 
ax::NodeEditor::NodeId GetNextNodeId();
 
ax::NodeEditor::LinkId GetNextLinkId();
 
ax::NodeEditor::PinId GetNextPinId();
 
#ifdef TESTING
 
void RegisterWatcherCallbackToInputPin(ax::NodeEditor::PinId id, const InputPin::WatcherCallback& callback);
 
void RegisterWatcherCallbackToLink(ax::NodeEditor::LinkId id, const InputPin::WatcherCallback& callback);
 
void ApplyWatcherCallbacks();
 
void RegisterPreInitCallback(std::function<void()> callback);
 
void CallPreInitCallback();
 
void RegisterCleanupCallback(std::function<void()> callback);
 
void CallCleanupCallback();
 
void ClearRegisteredCallbacks();
 
#endif
 
} // namespace NAV::NodeManager