Any objections to adding proxying of arrays? about luabridge3 HOT 7 CLOSED

        template <class TG, class TS = TG>
        Class<T>& addArrayProperty(char const* name, TG (*get)(const T*, int), void (*set)(T*, int, TS) = nullptr)
        {
            assert(name != nullptr);
            assertStackState(); // Stack: const table (co), class table (cl), static table (st)

            lua_pushlightuserdata(L, get);
            lua_pushlightuserdata(L, set);
            lua_pushcclosure(L, +[](lua_State *l) {
                // make the proxy table
                lua_newtable(l); // table
                lua_newtable(l); // metatable, table

                lua_pushstring(l, "__index"); // key, metatable, table
                lua_pushvalue(l, 1); // this pointer
                lua_pushvalue(l, lua_upvalueindex(1)); // getter pointer
                lua_pushcclosure(l, +[](lua_State *l) {
                    // Args: table, name
                    if (!lua_isnumber(l, 2)) {
                        return luaL_error(l, "Not an index '%s'", lua_tostring(l, 2));
                    }
                    T *s = reinterpret_cast<T *>(lua_touserdata(l, lua_upvalueindex(1)));
                    int idx = lua_tointeger(l, 2);
                    Stack<TG>::push(l, reinterpret_cast<TG(*)(const T*, int)>(lua_touserdata(l, lua_upvalueindex(2)))(s, idx));
                    return 1;
                }, 2); // func, key, metatable, table
                lua_rawset(l, -2); // metatable, table

                lua_pushstring(l, "__newindex"); // key, metatable, table
                lua_pushvalue(l, 1); // this pointer
                lua_pushvalue(l, lua_upvalueindex(2)); // setter pointer
                lua_pushcclosure(l, +[](lua_State *l) {
                    // Args: table, name, new value
                    if (!lua_isnumber(l, 2)) {
                        return luaL_error(l, "Not an index '%s'", lua_tostring(l, 2));
                    }
                    T *s = reinterpret_cast<T *>(lua_touserdata(l, lua_upvalueindex(1)));
                    int idx = lua_tointeger(l, 2);
                    void *setter = lua_touserdata(l, lua_upvalueindex(2));
                    if (setter == nullptr) {
                        return luaL_error(l, "read-only array");
                    } else {
                        reinterpret_cast<void(*)(T*, int, TS)>(setter)(s, idx, Stack<TS>::get(l, 3));
                    }
                    return 0;
                }, 2); // func, key, metatable, table
                lua_rawset(l, -2); // metatable, table
                lua_setmetatable(l, -1); // table
                return 1;
            }, 2); // Stack: co, cl, st, getter
            lua_pushvalue(L, -1); // Stack: co, cl, st, getter, getter
            CFunc::addGetter(L, name, -5); // Stack: co, cl, st, getter
            CFunc::addGetter(L, name, -3); // Stack: co, cl, st,
            
            return *this;
        }

    template <class TG, class TS = TG>
    Namespace& addArrayProperty(char const* name, TG (*get)(int), void (*set)(int, TS) = 0)
    {
        if (m_stackSize == 1)
            throw std::logic_error("addProperty () called on global namespace");

        assert(name != nullptr);
        assert(lua_istable(L, -1)); // Stack: namespace table (ns)

        lua_pushlightuserdata(L, get);
        lua_pushlightuserdata(L, set);
        lua_pushcclosure(L, +[](lua_State *l) {
            // make the proxy table
            lua_newtable(l); // table
            lua_newtable(l); // metatable, table

            lua_pushstring(l, "__index"); // key, metatable, table
            lua_pushvalue(l, lua_upvalueindex(1)); // getter pointer
            lua_pushcclosure(l, +[](lua_State *l) {
                // Args: table, name
                if (!lua_isnumber(l, 2)) {
                    return luaL_error(l, "Not an index '%s'", lua_tostring(l, 2));
                }
                int idx = lua_tointeger(l, 2);
                Stack<TG>::push(l, reinterpret_cast<TG(*)(int)>(lua_touserdata(l, lua_upvalueindex(1)))(idx));
                return 1;
            }, 1); // func, key, metatable, table
            lua_rawset(l, -2); // metatable, table

            lua_pushstring(l, "__newindex"); // key, metatable, table
            lua_pushvalue(l, lua_upvalueindex(2)); // setter pointer
            lua_pushcclosure(l, +[](lua_State *l) {
                // Args: table, name, new value
                if (!lua_isnumber(l, 2)) {
                    return luaL_error(l, "Not an index '%s'", lua_tostring(l, 2));
                }
                int idx = lua_tointeger(l, 2);
                void *setter = lua_touserdata(l, lua_upvalueindex(1));
                if (setter == nullptr) {
                    return luaL_error(l, "read-only array");
                } else {
                    reinterpret_cast<void(*)(int, TS)>(setter)(idx, Stack<TS>::get(l, 3));
                }
                return 0;
            }, 1); // func, key, metatable, table
            lua_rawset(l, -2); // metatable, table
            lua_setmetatable(l, -1); // table
            return 1;
        }, 2); // Stack: co, cl, st, getter
        lua_pushvalue(L, -1); // Stack: co, cl, st, getter, getter
        CFunc::addGetter(L, name, -5); // Stack: co, cl, st, getter
        CFunc::addGetter(L, name, -3); // Stack: co, cl, st,
        
        return *this;
    }

TEST_F(ClassMetaMethods, SimulateArray)
{
    using ContainerType = std::vector<std::string>;
    
    luabridge::getGlobalNamespace(L)
        .beginClass<ContainerType>("__x")
            .addFunction("__index", [](ContainerType* thiz, int index, lua_State* L) -> std::string
            {
                if (index < 0 || index >= thiz->size())
                    luaL_error(L, "Invalid index access in table %d", index);
                
                return (*thiz)[index];
            })
            .addFunction("__newindex", [](ContainerType* thiz, int index, const std::string& value, lua_State* L)
            {
                if (index < 0)
                    luaL_error(L, "Invalid index access in table %d", index);
                
                if (index >= thiz->size())
                    thiz->resize(index + 1);
                
                (*thiz)[index] = value;
            })
        .endClass();

    ContainerType data(1);
    data[0] = "abcdefg";
    
    luabridge::setGlobal(L, data, "x");
    
    runLua("result = x[0]");
    ASSERT_EQ("abcdefg", result<std::string>());

    runLua("x[10] = '123456'; result = x[10]");
    ASSERT_EQ("123456", result<std::string>());
}

    using ContainerType = std::vector<std::string>;

    ContainerType data(1);
    data[0] = "abcdefg";

    luabridge::getGlobalNamespace(L)
        .beginTable("xyz")
            .addMetaFunction("__index", [&data](luabridge::LuaRef, int index, lua_State* L)
            {
                if (index < 0 || index >= data.size())
                    luaL_error(L, "Invalid index access in table %d", index);

                return data[index];
            })
            .addMetaFunction("__newindex", [&data](luabridge::LuaRef, int index, luabridge::LuaRef ref, lua_State* L)
            {
                if (index < 0)
                    luaL_error(L, "Invalid index access in table %d", index);
                
                if (! ref.isString())
                    luaL_error(L, "Invalid value provided to set table at index %d", index);

                if (index >= data.size())
                    data.resize(index + 1);
                
                data[index] = ref.cast<std::string>();
            })
        .endTable();

    runLua("xyz[0] = '123'; result = xyz[0]");
    ASSERT_EQ("123", result<std::string>());