diff options
| -rw-r--r-- | src/Bindings/LuaChunkStay.cpp | 52 | ||||
| -rw-r--r-- | src/Bindings/LuaChunkStay.h | 13 | ||||
| -rw-r--r-- | src/Bindings/LuaState.cpp | 122 | ||||
| -rw-r--r-- | src/Bindings/LuaState.h | 79 | ||||
| -rw-r--r-- | src/Bindings/ManualBindings.cpp | 1 | ||||
| -rw-r--r-- | src/Bindings/ManualBindings_World.cpp | 29 |
6 files changed, 219 insertions, 77 deletions
diff --git a/src/Bindings/LuaChunkStay.cpp b/src/Bindings/LuaChunkStay.cpp index 145a9ee1b..d885470db 100644 --- a/src/Bindings/LuaChunkStay.cpp +++ b/src/Bindings/LuaChunkStay.cpp @@ -11,9 +11,7 @@ -cLuaChunkStay::cLuaChunkStay(cPluginLua & a_Plugin) : - m_Plugin(a_Plugin), - m_LuaState(nullptr) +cLuaChunkStay::cLuaChunkStay() { } @@ -21,49 +19,33 @@ cLuaChunkStay::cLuaChunkStay(cPluginLua & a_Plugin) : -bool cLuaChunkStay::AddChunks(int a_ChunkCoordTableStackPos) +bool cLuaChunkStay::AddChunks(const cLuaState::cStackTable & a_ChunkCoordsTable) { // This function is expected to be called just once, with all the coords in a table ASSERT(m_Chunks.empty()); - cPluginLua::cOperation Op(m_Plugin); - cLuaState & L = Op(); - - // Check that we got a table: - if (!lua_istable(L, a_ChunkCoordTableStackPos)) - { - LOGWARNING("%s: The parameter is not a table of coords (got %s). Ignoring the call.", - __FUNCTION__, lua_typename(L, lua_type(L, a_ChunkCoordTableStackPos)) - ); - L.LogStackTrace(); - return false; - } - // Add each set of coords: - int NumChunks = luaL_getn(L, a_ChunkCoordTableStackPos); - m_Chunks.reserve(static_cast<size_t>(NumChunks)); - for (int idx = 1; idx <= NumChunks; idx++) - { - // Push the idx-th element of the array onto stack top, check that it's a table: - lua_rawgeti(L, a_ChunkCoordTableStackPos, idx); - if (!lua_istable(L, -1)) + a_ChunkCoordsTable.ForEachArrayElement([=](cLuaState & a_LuaState, int a_Index) { - LOGWARNING("%s: Element #%d is not a table (got %s). Ignoring the element.", - __FUNCTION__, idx, lua_typename(L, -1) - ); - L.LogStackTrace(); - lua_pop(L, 1); - continue; + if (!lua_istable(a_LuaState, -1)) + { + LOGWARNING("%s: Element #%d is not a table (got %s). Ignoring the element.", + __FUNCTION__, a_Index, lua_typename(a_LuaState, -1) + ); + a_LuaState.LogStackTrace(); + lua_pop(a_LuaState, 1); + return false; + } + AddChunkCoord(a_LuaState, a_Index); + return false; } - AddChunkCoord(L, idx); - lua_pop(L, 1); - } + ); // If there are no chunks, log a warning and return failure: if (m_Chunks.empty()) { - LOGWARNING("%s: Zero chunks to stay.", __FUNCTION__); - L.LogStackTrace(); + LOGWARNING("%s: No valid chunk coords.", __FUNCTION__); + a_ChunkCoordsTable.GetLuaState().LogStackTrace(); return false; } diff --git a/src/Bindings/LuaChunkStay.h b/src/Bindings/LuaChunkStay.h index 51356d5b7..175260978 100644 --- a/src/Bindings/LuaChunkStay.h +++ b/src/Bindings/LuaChunkStay.h @@ -30,24 +30,19 @@ class cLuaChunkStay typedef cChunkStay super; public: - cLuaChunkStay(cPluginLua & a_Plugin); + cLuaChunkStay(); ~cLuaChunkStay() { } - /** Adds chunks in the specified on-stack Lua table. + /** Adds chunks in the specified Lua table. + Can be called only once. Returns true if any chunk added, false (plus log warning) if none. */ - bool AddChunks(int a_ChunkCoordTableStackPos); + bool AddChunks(const cLuaState::cStackTable & a_ChunkCoords); /** Enables the ChunkStay for the specified chunkmap, with the specified Lua callbacks. */ void Enable(cChunkMap & a_ChunkMap, cLuaState::cCallbackPtr a_OnChunkAvailable, cLuaState::cCallbackPtr a_OnAllChunksAvailable); protected: - /** The plugin which has created the ChunkStay, via cWorld:ChunkStay() binding method. */ - cPluginLua & m_Plugin; - - /** The Lua state associated with the callbacks. Only valid when enabled. */ - cLuaState * m_LuaState; - /** The Lua function to call in OnChunkAvailable. Only valid when enabled. */ cLuaState::cCallbackPtr m_OnChunkAvailable; diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp index e6a94091e..fd29e8e34 100644 --- a/src/Bindings/LuaState.cpp +++ b/src/Bindings/LuaState.cpp @@ -265,6 +265,26 @@ bool cLuaState::cCallback::RefStack(cLuaState & a_LuaState, int a_StackPos) //////////////////////////////////////////////////////////////////////////////// +// cLuaState::cOptionalCallback: + +bool cLuaState::cOptionalCallback::RefStack(cLuaState & a_LuaState, int a_StackPos) +{ + // If the stack pos is nil, make this an empty callback: + if (lua_isnil(a_LuaState, a_StackPos)) + { + Clear(); + return true; + } + + // Use default cCallback implementation: + return Super::RefStack(a_LuaState, a_StackPos); +} + + + + + +//////////////////////////////////////////////////////////////////////////////// // cLuaState::cTableRef: bool cLuaState::cTableRef::RefStack(cLuaState & a_LuaState, int a_StackPos) @@ -283,6 +303,45 @@ bool cLuaState::cTableRef::RefStack(cLuaState & a_LuaState, int a_StackPos) //////////////////////////////////////////////////////////////////////////////// +// cLuaState::cStackTable: + +cLuaState::cStackTable::cStackTable(cLuaState & a_LuaState, int a_StackPos): + m_LuaState(a_LuaState), + m_StackPos(a_StackPos) +{ + ASSERT(lua_istable(a_LuaState, a_StackPos)); +} + + + + + +void cLuaState::cStackTable::ForEachArrayElement(std::function<bool(cLuaState & a_LuaState, int a_Index)> a_ElementCallback) const +{ + auto numElements = luaL_getn(m_LuaState, m_StackPos); + #ifdef _DEBUG + auto stackTop = lua_gettop(m_LuaState); + #endif + for (int idx = 1; idx <= numElements; idx++) + { + // Push the idx-th element of the array onto stack top and call the callback: + lua_rawgeti(m_LuaState, m_StackPos, idx); + auto shouldAbort = a_ElementCallback(m_LuaState, idx); + ASSERT(lua_gettop(m_LuaState) == stackTop + 1); // The element callback must not change the Lua stack below the value + lua_pop(m_LuaState, 1); + if (shouldAbort) + { + // The callback wants to abort + return; + } + } +} + + + + + +//////////////////////////////////////////////////////////////////////////////// // cLuaState: cLuaState::cLuaState(const AString & a_SubsystemName) : @@ -1086,35 +1145,35 @@ bool cLuaState::GetStackValue(int a_StackPos, cCallbackPtr & a_Callback) -bool cLuaState::GetStackValue(int a_StackPos, cCallbackSharedPtr & a_Callback) +bool cLuaState::GetStackValue(int a_StackPos, cOptionalCallback & a_Callback) { - if (a_Callback == nullptr) - { - a_Callback = std::make_shared<cCallback>(); - } - return a_Callback->RefStack(*this, a_StackPos); + return a_Callback.RefStack(*this, a_StackPos); } -bool cLuaState::GetStackValue(int a_StackPos, cTableRef & a_TableRef) +bool cLuaState::GetStackValue(int a_StackPos, cOptionalCallbackPtr & a_Callback) { - return a_TableRef.RefStack(*this, a_StackPos); + if (a_Callback == nullptr) + { + a_Callback = cpp14::make_unique<cOptionalCallback>(); + } + return a_Callback->RefStack(*this, a_StackPos); } -bool cLuaState::GetStackValue(int a_StackPos, cTableRefPtr & a_TableRef) +bool cLuaState::GetStackValue(int a_StackPos, cCallbackSharedPtr & a_Callback) { - if (a_TableRef == nullptr) + if (a_Callback == nullptr) { - a_TableRef = cpp14::make_unique<cTableRef>(); + a_Callback = std::make_shared<cCallback>(); } - return a_TableRef->RefStack(*this, a_StackPos); + return a_Callback->RefStack(*this, a_StackPos); } @@ -1145,6 +1204,45 @@ bool cLuaState::GetStackValue(int a_StackPos, cRef & a_Ref) +bool cLuaState::GetStackValue(int a_StackPos, cStackTablePtr & a_StackTable) +{ + // Only allow tables to be stored in a_StackTable: + if (!lua_istable(m_LuaState, a_StackPos)) + { + return false; + } + + // Assign the StackTable to the specified stack position: + a_StackTable = cpp14::make_unique<cStackTable>(*this, a_StackPos); + return true; +} + + + + + +bool cLuaState::GetStackValue(int a_StackPos, cTableRef & a_TableRef) +{ + return a_TableRef.RefStack(*this, a_StackPos); +} + + + + + +bool cLuaState::GetStackValue(int a_StackPos, cTableRefPtr & a_TableRef) +{ + if (a_TableRef == nullptr) + { + a_TableRef = cpp14::make_unique<cTableRef>(); + } + return a_TableRef->RefStack(*this, a_StackPos); +} + + + + + bool cLuaState::GetStackValue(int a_StackPos, cTrackedRef & a_Ref) { return a_Ref.RefStack(*this, a_StackPos); diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h index bc88fbf1b..4def2c663 100644 --- a/src/Bindings/LuaState.h +++ b/src/Bindings/LuaState.h @@ -237,13 +237,43 @@ public: typedef SharedPtr<cCallback> cCallbackSharedPtr; + /** Same thing as cCallback, but GetStackValue() won't fail if the callback value is nil. + Used for callbacks that are optional - they needn't be present and in such a case they won't get called. */ + class cOptionalCallback: + public cCallback + { + typedef cCallback Super; + + public: + + cOptionalCallback(void) {} + + /** Set the contained callback to the function in the specified Lua state's stack position. + If a callback has been previously contained, it is unreferenced first. + Returns true on success, false on failure (not a function at the specified stack pos). */ + bool RefStack(cLuaState & a_LuaState, int a_StackPos); + + protected: + + /** This class cannot be copied, because it is tracked in the LuaState by-ptr. + Use cCallbackPtr for a copyable object. */ + cOptionalCallback(const cOptionalCallback &) = delete; + + /** This class cannot be moved, because it is tracked in the LuaState by-ptr. + Use cCallbackPtr for a copyable object. */ + cOptionalCallback(cOptionalCallback &&) = delete; + }; + typedef UniquePtr<cOptionalCallback> cOptionalCallbackPtr; + + /** Represents a stored Lua table with callback functions that C++ code can call. Is thread-safe and unload-safe. When Lua state is unloaded, the CallFn() will return failure instead of calling into non-existent code. - To receive the callback instance from the Lua side, use RefStack() or (better) cLuaState::GetStackValue() - with a cCallbackPtr. Note that instances of this class are tracked in the canon LuaState instance, so that - they can be invalidated when the LuaState is unloaded; due to multithreading issues they can only be tracked - by-ptr, which has an unfortunate effect of disabling the copy and move constructors. */ + To receive the cTableRef instance from the Lua side, use RefStack() or (better) cLuaState::GetStackValue() + with a cTableRefPtr. + Note that instances of this class are tracked in the canon LuaState instance, so that they can be + invalidated when the LuaState is unloaded; due to multithreading issues they can only be tracked by-ptr, + which has an unfortunate effect of disabling the copy and move constructors. */ class cTableRef: public cTrackedRef { @@ -342,6 +372,40 @@ public: }; + /** Represents a table on the Lua stack. + Provides easy access to the elements in the table. + Note that this class doesn't have cTrackedRef's thread-safeness and unload-safeness, it is expected to be + used for immediate queries in API bindings. */ + class cStackTable + { + public: + cStackTable(cLuaState & a_LuaState, int a_StackPos); + + /** Iterates over all array elements in the table consecutively and calls the a_ElementCallback for each. + The callback receives the LuaState in which the table resides, and the element's index. The LuaState has + the element on top of its stack. If the callback returns true, the iteration is aborted, if it returns + false, the iteration continues with the next element. */ + void ForEachArrayElement(std::function<bool(cLuaState & a_LuaState, int a_Index)> a_ElementCallback) const; + + /** Iterates over all dictionary elements in the table in random order, and calls the a_ElementCallback for + each of them. + The callback receives the LuaState in which the table reside. The LuaState has the element on top of its + stack, and the element's key just below it. If the callback returns true, the iteration is aborted, if it + returns false, the iteration continues with the next element. */ + void ForEachElement(std::function<bool(cLuaState & a_LuaState)> a_ElementCallback) const; + + cLuaState & GetLuaState(void) const { return m_LuaState; } + + protected: + /** The Lua state in which the table resides. */ + cLuaState & m_LuaState; + + /** The stack index where the table resides in the Lua state. */ + int m_StackPos; + }; + typedef UniquePtr<cStackTable> cStackTablePtr; + + /** Creates a new instance. The LuaState is not initialized. a_SubsystemName is used for reporting problems in the console, it is "plugin %s" for plugins, or "LuaScript" for the cLuaScript template @@ -439,10 +503,13 @@ public: bool GetStackValue(int a_StackPos, cCallback & a_Callback); bool GetStackValue(int a_StackPos, cCallbackPtr & a_Callback); bool GetStackValue(int a_StackPos, cCallbackSharedPtr & a_Callback); - bool GetStackValue(int a_StackPos, cTableRef & a_TableRef); - bool GetStackValue(int a_StackPos, cTableRefPtr & a_TableRef); + bool GetStackValue(int a_StackPos, cOptionalCallback & a_Callback); + bool GetStackValue(int a_StackPos, cOptionalCallbackPtr & a_Callback); bool GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result); bool GetStackValue(int a_StackPos, cRef & a_Ref); + bool GetStackValue(int a_StackPos, cStackTablePtr & a_StackTable); + bool GetStackValue(int a_StackPos, cTableRef & a_TableRef); + bool GetStackValue(int a_StackPos, cTableRefPtr & a_TableRef); bool GetStackValue(int a_StackPos, cTrackedRef & a_Ref); bool GetStackValue(int a_StackPos, cTrackedRefPtr & a_Ref); bool GetStackValue(int a_StackPos, cTrackedRefSharedPtr & a_Ref); diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp index b6a10adf3..20792393d 100644 --- a/src/Bindings/ManualBindings.cpp +++ b/src/Bindings/ManualBindings.cpp @@ -12,7 +12,6 @@ #include "PluginLua.h" #include "PluginManager.h" #include "LuaWindow.h" -#include "LuaChunkStay.h" #include "../Root.h" #include "../World.h" #include "../Entities/Player.h" diff --git a/src/Bindings/ManualBindings_World.cpp b/src/Bindings/ManualBindings_World.cpp index b3170a636..56a4ee65b 100644 --- a/src/Bindings/ManualBindings_World.cpp +++ b/src/Bindings/ManualBindings_World.cpp @@ -79,33 +79,34 @@ static int tolua_cWorld_ChunkStay(lua_State * tolua_S) return 0; } - cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S); - if (Plugin == nullptr) + // Read the params: + cWorld * world; + cLuaState::cStackTablePtr chunkCoords; + cLuaState::cOptionalCallbackPtr onChunkAvailable, onAllChunksAvailable; // Callbacks may be unassigned at all - as a request to load / generate chunks + if (!L.GetStackValues(1, world, chunkCoords, onChunkAvailable, onAllChunksAvailable)) { + LOGWARNING("cWorld:ChunkStay(): Cannot read parameters, bailing out."); + L.LogStackTrace(); + L.LogStackValues("Values on the stack"); return 0; } - - // Read the params: - cWorld * World = reinterpret_cast<cWorld *>(tolua_tousertype(tolua_S, 1, nullptr)); - if (World == nullptr) + if (world == nullptr) { LOGWARNING("World:ChunkStay(): invalid world parameter"); L.LogStackTrace(); return 0; } + ASSERT(chunkCoords != nullptr); // If the table was invalid, GetStackValues() would have failed - cLuaChunkStay * ChunkStay = new cLuaChunkStay(*Plugin); - - if (!ChunkStay->AddChunks(2)) + // Read the chunk coords: + auto chunkStay = cpp14::make_unique<cLuaChunkStay>(); + if (!chunkStay->AddChunks(*chunkCoords)) { - delete ChunkStay; - ChunkStay = nullptr; return 0; } - cLuaState::cCallbackPtr onChunkAvailable, onAllChunksAvailable; - L.GetStackValues(3, onChunkAvailable, onAllChunksAvailable); // Callbacks may be unassigned at all - as a request to load / generate chunks - ChunkStay->Enable(*World->GetChunkMap(), std::move(onChunkAvailable), std::move(onAllChunksAvailable)); + // Activate the ChunkStay: + chunkStay.release()->Enable(*world->GetChunkMap(), std::move(onChunkAvailable), std::move(onAllChunksAvailable)); return 0; } |