dl_lua_register_container.h

浏览该文件的文档.

#pragma once
 
#include <LuaBridge/Array.h>
#include <LuaBridge/Vector.h>
//
//namespace luabridge {
//
//  //=================================================================================================
//  /**
//   * @brief Stack specialization for `dl::Array`.
//   */
//  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