callback.hpp

#pragma once
 
#include <memory>
#include <string>
#include <utility>
 
#include "plugify/global.h"
#include "plugify/mem_addr.hpp"
#include "plugify/method.hpp"
#include "plugify/property.hpp"
#include "plugify/signarure.hpp"
#include "plugify/value_type.hpp"
#include "plg/inplace_vector.hpp"
 
namespace plugify {
    class PLUGIFY_API JitCallback {
    public:
        JitCallback();
 
        JitCallback(const JitCallback& other) = delete;
 
        JitCallback(JitCallback&& other) noexcept;
 
        ~JitCallback();
 
        using CallbackHandler = void (*)(
            const Method* method,
            MemAddr data,
            uint64_t* params,
            size_t count,
            /*uint128_t*/ void* ret
        );
 
        using HiddenParam = bool (*)(ValueType);
 
        MemAddr GetJitFunc(
            const Signature& signature,
            const Method* method,
            CallbackHandler callback,
            MemAddr data,
            bool hidden
        );
 
        MemAddr GetJitFunc(
            const Method& method,
            CallbackHandler callback,
            MemAddr data = nullptr,
            HiddenParam hidden = &ValueUtils::IsHiddenParam
        );
 
        MemAddr GetFunction() const noexcept;
 
        MemAddr GetUserData() const noexcept;
 
        std::string_view GetError() noexcept;
 
        JitCallback& operator=(const JitCallback& other) = delete;
 
        JitCallback& operator=(JitCallback&& other) noexcept;
 
        PLUGIFY_ACCESS : struct Impl;
        PLUGIFY_NO_DLL_EXPORT_WARNING(std::unique_ptr<Impl> _impl;)
    };
 
    template <typename T>
    concept SlotStorable = std::is_trivially_copyable_v<T> && sizeof(T) <= sizeof(uint64_t);
 
    class ParametersSpan {
    public:
        using slot_type = uint64_t;
 
        ParametersSpan(slot_type* data, size_t count) noexcept
            : _data(data)
            , _count(count) {
        }
 
        template <typename T>
            requires SlotStorable<T>
        T Get(size_t index) const noexcept {
            assert(index < _count && "Index out of bounds");
            T result{};
            std::memcpy(&result, &_data[index], sizeof(T));
            return result;
        }
 
        template <typename T>
            requires SlotStorable<T>
        void Set(size_t index, const T& value) noexcept {
            assert(index < _count && "Index out of bounds");
            std::memcpy(&_data[index], &value, sizeof(T));
        }
 
    private:
        slot_type* _data;
        [[maybe_unused]] size_t _count;
    };
 
    class ReturnSlot {
    public:
        using type = void;
 
        explicit ReturnSlot(type* data, size_t size) noexcept
            : _data(data)
            , _size(size) {
        }
 
        template <typename T>
            requires std::is_trivially_copyable_v<T>
        void Set(const T& value) noexcept {
            assert(sizeof(T) <= _size && "Return value too large");
            std::memcpy(_data, &value, sizeof(T));
        }
 
        template <typename T>
            requires std::is_trivially_copyable_v<T>
        T Get() const noexcept {
            assert(sizeof(T) <= _size && "Return type too large");
            T result{};
            std::memcpy(&result, _data, sizeof(T));
            return result;
        }
 
        template <typename T, typename... Args>
            // requires std::is_trivially_destructible_v<T>
        void Construct(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...))) {
            assert(sizeof(T) <= _size && "Type too large");
            std::construct_at(reinterpret_cast<T*>(_data), std::forward<Args>(args)...);
        }
 
    private:
        type* _data;
        [[maybe_unused]] size_t _size;
    };
}  // namespace plugify