Move LindaFactory in separate files

7 files changed, 205 insertions, 152 deletions

diff --git a/src/Makefile b/src/Makefile
index d6bdfd7..06bbcd0 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -7,7 +7,7 @@
 
 MODULE=lanes
 
-SRC=lanes.c cancel.cpp compat.cpp threading.cpp tools.cpp state.cpp linda.cpp deep.cpp keeper.cpp universe.cpp
+SRC=lanes.c cancel.cpp compat.cpp threading.cpp tools.cpp state.cpp linda.cpp lindafactory.cpp deep.cpp keeper.cpp universe.cpp
 
 OBJ=$(SRC:.c=.o)
 
diff --git a/src/deep.h b/src/deep.h
index 673e93a..45f7841 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -2,7 +2,7 @@
 
 /*
  * public 'deep' API to be used by external modules if they want to implement Lanes-aware userdata
- * said modules will have to link against lanes (it is not really possible to separate the 'deep userdata' implementation from the rest of Lanes)
+ * said modules can either link against lanes, or embed compat.cpp/h deep.cpp/h tools.cpp/h universe.cpp/h
  */
 
 #ifdef __cplusplus
@@ -69,16 +69,16 @@ class DeepFactory
     private:
 
     // NVI: private overrides
-    virtual DeepPrelude* newDeepObjectInternal(lua_State* L) const = 0;
-    virtual void deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const = 0;
-    virtual void createMetatable(lua_State* L) const = 0;
+    virtual DeepPrelude* newDeepObjectInternal(lua_State* L_) const = 0;
+    virtual void deleteDeepObjectInternal(lua_State* L_, DeepPrelude* o_) const = 0;
+    virtual void createMetatable(lua_State* L_) const = 0;
     virtual char const* moduleName() const = 0;
 
     public:
 
     // NVI: public interface
-    int pushDeepUserdata(DestState L, int nuv_) const;
-    DeepPrelude* toDeep(lua_State* L, int index) const;
-    static void DeleteDeepObject(lua_State* L, DeepPrelude* o_);
-    static char const* PushDeepProxy(DestState L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
+    int pushDeepUserdata(DestState L_, int nuv_) const;
+    DeepPrelude* toDeep(lua_State* L_, int index_) const;
+    static void DeleteDeepObject(lua_State* L_, DeepPrelude* o_);
+    static char const* PushDeepProxy(DestState L_, DeepPrelude* o_, int nuv_, LookupMode mode_);
 };
diff --git a/src/lanesconf.h b/src/lanesconf.h
index 8c66bd1..7b4ff93 100644
--- a/src/lanesconf.h
+++ b/src/lanesconf.h
@@ -19,10 +19,8 @@
 // file-level static variable: in 'global' namespace, prefix s, followed by an uppercase letter
 // file-level function (static or not): no prefix, start with an uppercase letter
 // class/struct/enum type: no prefix, start with an uppercase letter
-// static class member: prefix s, followed by an uppercase letter
-// regular class member: no prefix, start with a lowercase letter
-// static class method: no prefix, start with an uppercase letter
-// regular class method: no prefix, start with a lowercase letter
+// static class member/method: no prefix, start with an uppercase letter
+// regular class member/method: no prefix, start with a lowercase letter
 // function argument: suffix _
 // static function variable: prefix s, followed by an uppercase letter
 // function local variable: prefix l, followed by an uppercase letter
diff --git a/src/linda.cpp b/src/linda.cpp
index 590b487..bc931ac 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -7,7 +7,7 @@
 /*
 ===============================================================================
 
-Copyright (C) 2018 benoit Germain <bnt.germain@gmail.com>
+Copyright (C) 2018-2024 benoit Germain <bnt.germain@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -35,29 +35,13 @@ THE SOFTWARE.
 #include "compat.h"
 #include "keeper.h"
 #include "lanes_private.h"
+#include "lindafactory.h"
 #include "threading.h"
 #include "tools.h"
 #include "universe.h"
 
 #include <functional>
 
-// xxh64 of string "kLindaBatched" generated at https://www.pelock.com/products/hash-calculator
-static constexpr UniqueKey kLindaBatched{ 0xB8234DF772646567ull, "linda.batched" };
-
-// #################################################################################################
-
-class LindaFactory : public DeepFactory
-{
-    private:
-
-    DeepPrelude* newDeepObjectInternal(lua_State* L) const override;
-    void deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const override;
-    void createMetatable(lua_State* L) const override;
-    char const* moduleName() const override;
-};
-// I'm not totally happy with having a global variable. But since it's stateless, it will do for the time being.
-static LindaFactory g_LindaFactory;
-
 // #################################################################################################
 // #################################################################################################
 
@@ -67,7 +51,7 @@ static LindaFactory g_LindaFactory;
 static constexpr uintptr_t kPointerMagicShift{ 3 };
 
 Linda::Linda(Universe* U_, LindaGroup group_, char const* name_, size_t len_)
-: DeepPrelude{ g_LindaFactory }
+: DeepPrelude{ LindaFactory::Instance }
 , U{ U_ }
 , m_keeper_index{ (group_ ? group_ : static_cast<int>(std::bit_cast<uintptr_t>(this) >> kPointerMagicShift)) % U_->keepers->nb_keepers }
 {
@@ -132,7 +116,7 @@ char const* Linda::getName() const
 template <bool OPT>
 [[nodiscard]] static inline Linda* ToLinda(lua_State* L_, int idx_)
 {
-    Linda* const linda{ static_cast<Linda*>(g_LindaFactory.toDeep(L_, idx_)) };
+    Linda* const linda{ static_cast<Linda*>(LindaFactory::Instance.toDeep(L_, idx_)) };
     if constexpr (!OPT)
     {
         luaL_argcheck(L_, linda != nullptr, idx_, "expecting a linda object"); // doesn't return if linda is nullptr
@@ -856,124 +840,26 @@ LUAG_FUNC(linda_towatch)
 
 // #################################################################################################
 
-DeepPrelude* LindaFactory::newDeepObjectInternal(lua_State* L) const
-{
-    size_t name_len = 0;
-    char const* linda_name = nullptr;
-    LindaGroup linda_group{ 0 };
-    // should have a string and/or a number of the stack as parameters (name and group)
-    switch (lua_gettop(L))
-    {
-        default: // 0
-        break;
-
-        case 1: // 1 parameter, either a name or a group
-        if (lua_type(L, -1) == LUA_TSTRING)
-        {
-            linda_name = lua_tolstring(L, -1, &name_len);
-        }
-        else
-        {
-            linda_group = LindaGroup{ static_cast<int>(lua_tointeger(L, -1)) };
-        }
-        break;
-
-        case 2: // 2 parameters, a name and group, in that order
-        linda_name = lua_tolstring(L, -2, &name_len);
-        linda_group = LindaGroup{ static_cast<int>(lua_tointeger(L, -1)) };
-        break;
-    }
-
-    /* The deep data is allocated separately of Lua stack; we might no
-        * longer be around when last reference to it is being released.
-        * One can use any memory allocation scheme.
-        * just don't use L's allocF because we don't know which state will get the honor of GCing the linda
-        */
-    Universe* const U{ universe_get(L) };
-    Linda* linda{ new (U) Linda{ U, linda_group, linda_name, name_len } };
-    return linda;
-}
-
-// #################################################################################################
-
-void LindaFactory::deleteDeepObjectInternal(lua_State* L, DeepPrelude* o_) const
-{
-    Linda* const linda{ static_cast<Linda*>(o_) };
-    LUA_ASSERT(L, linda);
-    Keeper* const myK{ linda->whichKeeper() };
-    // if collected after the universe, keepers are already destroyed, and there is nothing to clear
-    if (myK)
-    {
-        // if collected from my own keeper, we can't acquire/release it
-        // because we are already inside a protected area, and trying to do so would deadlock!
-        bool const need_acquire_release{ myK->L != L };
-        // Clean associated structures in the keeper state.
-        Keeper* const K{ need_acquire_release ? linda->acquireKeeper() : myK };
-        // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
-        [[maybe_unused]] KeeperCallResult const result{ keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0) };
-        LUA_ASSERT(L, result.has_value() && result.value() == 0);
-        if (need_acquire_release)
-        {
-            linda->releaseKeeper(K);
-        }
-    }
-
-    delete linda; // operator delete overload ensures things go as expected
-}
-
-// #################################################################################################
-
-static luaL_Reg const s_LindaMT[] =
-{
-    { "__concat", LG_linda_concat },
-    { "__tostring", LG_linda_tostring },
-    { "__towatch", LG_linda_towatch }, // Decoda __towatch support
-    { "cancel", LG_linda_cancel },
-    { "count", LG_linda_count },
-    { "deep", LG_linda_deep },
-    { "dump", LG_linda_dump },
-    { "get", LG_linda_get },
-    { "limit", LG_linda_limit },
-    { "receive", LG_linda_receive },
-    { "send", LG_linda_send },
-    { "set", LG_linda_set },
-    { nullptr, nullptr }
-};
-
-void LindaFactory::createMetatable(lua_State* L) const
-{
-    STACK_CHECK_START_REL(L, 0);
-    lua_newtable(L);
-    // metatable is its own index
-    lua_pushvalue(L, -1);
-    lua_setfield(L, -2, "__index");
-
-    // protect metatable from external access
-    lua_pushliteral(L, "Linda");
-    lua_setfield(L, -2, "__metatable");
-
-    // the linda functions
-    luaL_setfuncs(L, s_LindaMT, 0);
-
-    // some constants
-    kLindaBatched.pushKey(L);
-    lua_setfield(L, -2, "batched");
-
-    kNilSentinel.pushKey(L);
-    lua_setfield(L, -2, "null");
-
-    STACK_CHECK(L, 1);
-}
-
-// #################################################################################################
-
-char const* LindaFactory::moduleName() const
-{
-    // linda is a special case because we know lanes must be loaded from the main lua state
-    // to be able to ever get here, so we know it will remain loaded as long a the main state is around
-    // in other words, forever.
-    return nullptr;
-}
+namespace global {
+    static luaL_Reg const sLindaMT[] = {
+        { "__concat", LG_linda_concat },
+        { "__tostring", LG_linda_tostring },
+        { "__towatch", LG_linda_towatch }, // Decoda __towatch support
+        { "cancel", LG_linda_cancel },
+        { "count", LG_linda_count },
+        { "deep", LG_linda_deep },
+        { "dump", LG_linda_dump },
+        { "get", LG_linda_get },
+        { "limit", LG_linda_limit },
+        { "receive", LG_linda_receive },
+        { "send", LG_linda_send },
+        { "set", LG_linda_set },
+        { nullptr, nullptr }
+    };
+} // namespace global
+// it's somewhat awkward to instanciate the LindaFactory here instead of lindafactory.cpp,
+// but that's necessary to provide s_LindaMT without exposing it outside linda.cpp.
+/*static*/ LindaFactory LindaFactory::Instance{ global::sLindaMT };
 
 // #################################################################################################
 
@@ -996,5 +882,5 @@ LUAG_FUNC(linda)
         luaL_checktype(L, 1, LUA_TSTRING);
         luaL_checktype(L, 2, LUA_TNUMBER);
     }
-    return g_LindaFactory.pushDeepUserdata(DestState{ L }, 0);
+    return LindaFactory::Instance.pushDeepUserdata(DestState{ L }, 0);
 }
diff --git a/src/linda.h b/src/linda.h
index f3b1844..21b6ecc 100644
--- a/src/linda.h
+++ b/src/linda.h
@@ -13,6 +13,11 @@ struct Keeper;
 
 // #################################################################################################
 
+// xxh64 of string "kLindaBatched" generated at https://www.pelock.com/products/hash-calculator
+static constexpr UniqueKey kLindaBatched{ 0xB8234DF772646567ull, "linda.batched" };
+
+// #################################################################################################
+
 using LindaGroup = Unique<int>;
 
 class Linda : public DeepPrelude // Deep userdata MUST start with this header
diff --git a/src/lindafactory.cpp b/src/lindafactory.cpp
new file mode 100644
index 0000000..81e472d
--- /dev/null
+++ b/src/lindafactory.cpp
@@ -0,0 +1,136 @@
+/*
+ * LINDAFACTORY.CPP                    Copyright (c) 2024-, Benoit Germain
+ *
+ * Linda deep userdata factory
+*/
+
+/*
+===============================================================================
+
+Copyright (C) 2024- benoit Germain <bnt.germain@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+*/
+
+#include "lindafactory.h"
+
+#include "linda.h"
+
+// #################################################################################################
+
+void LindaFactory::createMetatable(lua_State* L_) const
+{
+    STACK_CHECK_START_REL(L_, 0);
+    lua_newtable(L_);
+    // metatable is its own index
+    lua_pushvalue(L_, -1);
+    lua_setfield(L_, -2, "__index");
+
+    // protect metatable from external access
+    lua_pushliteral(L_, "Linda");
+    lua_setfield(L_, -2, "__metatable");
+
+    // the linda functions
+    luaL_setfuncs(L_, mLindaMT, 0);
+
+    // some constants
+    kLindaBatched.pushKey(L_);
+    lua_setfield(L_, -2, "batched");
+
+    kNilSentinel.pushKey(L_);
+    lua_setfield(L_, -2, "null");
+
+    STACK_CHECK(L_, 1);
+}
+
+// #################################################################################################
+
+void LindaFactory::deleteDeepObjectInternal(lua_State* L_, DeepPrelude* o_) const
+{
+    Linda* const linda{ static_cast<Linda*>(o_) };
+    LUA_ASSERT(L_, linda);
+    Keeper* const myK{ linda->whichKeeper() };
+    // if collected after the universe, keepers are already destroyed, and there is nothing to clear
+    if (myK)
+    {
+        // if collected from my own keeper, we can't acquire/release it
+        // because we are already inside a protected area, and trying to do so would deadlock!
+        bool const need_acquire_release{ myK->L != L_ };
+        // Clean associated structures in the keeper state.
+        Keeper* const K{ need_acquire_release ? linda->acquireKeeper() : myK };
+        // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
+        [[maybe_unused]] KeeperCallResult const result{ keeper_call(linda->U, K->L, KEEPER_API(clear), L_, linda, 0) };
+        LUA_ASSERT(L_, result.has_value() && result.value() == 0);
+        if (need_acquire_release)
+        {
+            linda->releaseKeeper(K);
+        }
+    }
+
+    delete linda; // operator delete overload ensures things go as expected
+}
+
+// #################################################################################################
+
+char const* LindaFactory::moduleName() const
+{
+    // linda is a special case because we know lanes must be loaded from the main lua state
+    // to be able to ever get here, so we know it will remain loaded as long a the main state is around
+    // in other words, forever.
+    return nullptr;
+}
+
+// #################################################################################################
+
+DeepPrelude* LindaFactory::newDeepObjectInternal(lua_State* L_) const
+{
+    size_t name_len{ 0 };
+    char const* linda_name{ nullptr };
+    LindaGroup linda_group{ 0 };
+    // should have a string and/or a number of the stack as parameters (name and group)
+    switch (lua_gettop(L_))
+    {
+        default: // 0
+        break;
+
+        case 1: // 1 parameter, either a name or a group
+        if (lua_type(L_, -1) == LUA_TSTRING)
+        {
+            linda_name = lua_tolstring(L_, -1, &name_len);
+        }
+        else
+        {
+            linda_group = LindaGroup{ static_cast<int>(lua_tointeger(L_, -1)) };
+        }
+        break;
+
+        case 2: // 2 parameters, a name and group, in that order
+        linda_name = lua_tolstring(L_, -2, &name_len);
+        linda_group = LindaGroup{ static_cast<int>(lua_tointeger(L_, -1)) };
+        break;
+    }
+
+    // The deep data is allocated separately of Lua stack; we might no longer be around when last reference to it is being released.
+    // One can use any memory allocation scheme. Just don't use L's allocF because we don't know which state will get the honor of GCing the linda
+    Universe* const U{ universe_get(L_) };
+    Linda* const linda{ new (U) Linda{ U, linda_group, linda_name, name_len } };
+    return linda;
+}
diff --git a/src/lindafactory.h b/src/lindafactory.h
new file mode 100644
index 0000000..d31af1f
--- /dev/null
+++ b/src/lindafactory.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "deep.h"
+
+// #################################################################################################
+
+class LindaFactory
+: public DeepFactory
+{
+    public:
+
+    // I'm not totally happy with having a 'global' variable. Maybe it should be dynamically created and stored somewhere in the universe?
+    static LindaFactory Instance;
+
+    LindaFactory(luaL_Reg const lindaMT_[])
+    : mLindaMT{ lindaMT_ }
+    {
+    }
+
+    private:
+
+    luaL_Reg const* const mLindaMT{ nullptr };
+
+    void createMetatable(lua_State* L_) const override;
+    void deleteDeepObjectInternal(lua_State* L_, DeepPrelude* o_) const override;
+    char const* moduleName() const override;
+    DeepPrelude* newDeepObjectInternal(lua_State* L_) const override;
+};