dl_lua_register_container.h

浏览该文件的文档.

#pragma once
 
#include <LuaBridge/Array.h>
#include <LuaBridge/Vector.h>
 
// Array 绑定
namespace luabridge {
 
    //=================================================================================================
    template <class T, std::size_t Size>
    struct Stack<dl::Array<T, Size>>
    {
        using Type = dl::Array<T, Size>;
 
        [[nodiscard]] static Result push(lua_State* L, const Type& array)
        {
#if LUABRIDGE_SAFE_STACK_CHECKS
            if (!lua_checkstack(L, 3))
                return makeErrorCode(ErrorCode::LuaStackOverflow);
#endif
 
            StackRestore stackRestore(L);
 
            lua_createtable(L, static_cast<int>(Size), 0);
 
            for (std::size_t i = 0; i < Size; ++i)
            {
                lua_pushinteger(L, static_cast<lua_Integer>(i + 1));
 
                auto result = Stack<T>::push(L, array[i]);
                if (!result)
                    return result;
 
                lua_settable(L, -3);
            }
 
            stackRestore.reset();
            return {};
        }
 
        [[nodiscard]] static TypeResult<Type> get(lua_State* L, int index)
        {
            if (!lua_istable(L, index))
                return makeErrorCode(ErrorCode::InvalidTypeCast);
 
            if (get_length(L, index) != Size)
                return makeErrorCode(ErrorCode::InvalidTableSizeInCast);
 
            const StackRestore stackRestore(L);
 
            Type array;
 
            int absIndex = lua_absindex(L, index);
            lua_pushnil(L);
 
            int arrayIndex = 0;
            while (lua_next(L, absIndex) != 0)
            {
                auto item = Stack<T>::get(L, -1);
                if (!item)
                    return makeErrorCode(ErrorCode::InvalidTypeCast);
 
                array[arrayIndex++] = *item;
                lua_pop(L, 1);
            }
 
            return array;
        }
 
        [[nodiscard]] static bool isInstance(lua_State* L, int index)
        {
            return lua_istable(L, index) && get_length(L, index) == Size;
        }
    };
 
} // namespace luabridge
 
namespace luabridge{
//=================================================================================================
template <class T, class Index>
struct Stack<dl::Vector2<T, Index>, T>
{
    using Type = dl::Vector2<T, Index>;
 
    [[nodiscard]] static Result push(lua_State* L, const Type& vec)
    {
#if LUABRIDGE_SAFE_STACK_CHECKS
        if (!lua_checkstack(L, 3))
            return makeErrorCode(ErrorCode::LuaStackOverflow);
#endif
 
        StackRestore stackRestore(L);
 
        lua_createtable(L, 0, static_cast<int>(vec.size()));
 
        for (auto it = vec.begin(); it != vec.end(); ++it)
        {
            auto result = Stack<T>::push(L, *it);
            if (!result)
                return result;
 
            lua_settable(L, -3);
        }
 
        stackRestore.reset();
        return {};
    }
 
    [[nodiscard]] static TypeResult<Type> get(lua_State* L, int index)
    {
        if (!lua_istable(L, index))
            return makeErrorCode(ErrorCode::InvalidTypeCast);
 
        const StackRestore stackRestore(L);
 
        Type vec;
 
        int absIndex = lua_absindex(L, index);
        lua_pushnil(L);
 
        while (lua_next(L, absIndex) != 0)
        {
            auto value = Stack<T>::get(L, -1);
            if (!value)
                return makeErrorCode(ErrorCode::InvalidTypeCast);
 
            vec.emplace_back(*value);
            lua_pop(L, 1);
        }
 
        return vec;
    }
 
    [[nodiscard]] static bool isInstance(lua_State* L, int index)
    {
        return lua_istable(L, index);
    }
};
 
} // namespace luabridge