NodeFunction.hpp

#pragma once
 
// Standard.
#include <functional>
#include <optional>
 
// Custom.
#include "game/GameManager.h"
 
namespace ne {
    template <typename FunctionReturnType, typename... FunctionArgs> class NodeFunction;
 
    template <typename FunctionReturnType, typename... FunctionArgs>
    class NodeFunction<FunctionReturnType(FunctionArgs...)> {
    public:
        NodeFunction() = default;
 
        NodeFunction(size_t iNodeId, const std::function<FunctionReturnType(FunctionArgs...)>& callback) {
            static_assert(
                std::is_same_v<FunctionReturnType, void>,
                "return type must be `void` - this is a current limitation");
 
            this->iNodeId = iNodeId;
            this->callback = callback;
        }
 
        NodeFunction(const NodeFunction& other) = default;
 
        NodeFunction& operator=(const NodeFunction& other) = default;
 
        NodeFunction(NodeFunction&& other) noexcept = default;
 
        NodeFunction& operator=(NodeFunction&& other) noexcept = default;
 
        bool operator()(FunctionArgs&&... args) {
            if (isNodeSpawned()) {
                callback(std::forward<FunctionArgs>(args)...);
                return false;
            }
 
            return true;
        }
 
        bool isNodeSpawned() {
            // Get game manager.
            const auto pGameManager = GameManager::get();
            if (pGameManager == nullptr) [[unlikely]] {
                return false;
            }
 
            // Make sure the game manager is not being destroyed.
            if (pGameManager->isBeingDestroyed()) [[unlikely]] {
                // Exit now because it might be dangerous to continue if we are on a non-main thread.
                return false;
            }
 
            return pGameManager->isNodeSpawned(iNodeId);
        }
 
    private:
        std::function<FunctionReturnType(FunctionArgs...)> callback;
 
        size_t iNodeId = 0;
    };
} // namespace ne