NativeLatentFunction.h

Go to the documentation of this file.

#pragma once
 
#include "RE/B/BSTSmartPointer.h"
#include "RE/I/IObjectHandlePolicy.h"
#include "RE/I/IVirtualMachine.h"
#include "RE/N/NativeFunction.h"
#include "RE/P/PackUnpack.h"
#include "RE/T/TypeTraits.h"
#include "RE/V/Variable.h"
#include "RE/V/VirtualMachine.h"
 
namespace RE
{
    namespace BSScript
    {
        template <bool IS_LONG, class F, class callbackR, class latentR, class Base, class... Args>
        class NativeLatentFunction : public NativeFunction<IS_LONG, F, std::underlying_type_t<callbackR>, Base, Args...>
        {
        public:
            using result_type = callbackR;
            using base_type = Base;
            using function_type = F;
 
            NativeLatentFunction() = delete;
            NativeLatentFunction(const NativeLatentFunction&) = delete;
            NativeLatentFunction(NativeLatentFunction&&) = delete;
 
            NativeLatentFunction(std::string_view a_fnName, std::string_view a_className, function_type a_callback) :
                NativeFunction<IS_LONG, F, std::underlying_type_t<callbackR>, Base, Args...>(a_fnName, a_className, a_callback)
            {
                this->_retType = GetRawType<latentR>();
                this->_isLatent = true;
            }
 
            ~NativeLatentFunction() override = default;  // 00
        };
    }
 
    template <class R, class F, class = void>
    class NativeLatentFunction;
 
    template <class R, class Int, class F, class Cls, class... Args>
    class NativeLatentFunction<R, F(BSScript::Internal::VirtualMachine*, Int, Cls, Args...), std::enable_if_t<BSScript::is_valid_latent_long_sig_v<R, Int, F, Cls, Args...>>> :
        public BSScript::NativeLatentFunction<true, F(BSScript::Internal::VirtualMachine*, Int, Cls, Args...), F, R, Cls, Args...>
    {
    private:
        using super = BSScript::NativeLatentFunction<true, F(BSScript::Internal::VirtualMachine*, Int, Cls, Args...), F, R, Cls, Args...>;
 
    public:
        using result_type = typename super::result_type;
        using base_type = typename super::base_type;
        using function_type = typename super::function_type;
 
        using super::super;
    };
 
    namespace BSScript
    {
        enum LatentStatus : bool
        {
            kFailed,   // Failed to start latent funciton, return NONE and log error
            kStarted,  // Latent function started, script will pause until latent function finishes
        };
 
        template <class R, class F>
        void IVirtualMachine::RegisterLatentFunction(std::string_view a_fnName, std::string_view a_className, F a_callback, bool a_callableFromTasklets)
        {
            BindNativeMethod(new RE::NativeLatentFunction<R, std::remove_pointer_t<F>>(a_fnName, a_className, a_callback));
            if (a_callableFromTasklets) {
                SetCallableFromTasklets(a_className.data(), a_fnName.data(), true);
            }
        }
 
        template <class V>
            requires is_return_convertible_v<V>
        void IVirtualMachine::ReturnLatentResult(VMStackID a_stackID, V a_result)
        {
            auto var = RE::BSScript::Variable();
            var.Pack(a_result);
            ReturnFromLatent(a_stackID, var);
        }
    }
}