C++ migration: deep userdata API rework. bye bye idfunc, hello DeepFactory

1 files changed, 44 insertions, 18 deletions

diff --git a/src/deep.h b/src/deep.h
index 7be5c5d..7c0aa6d 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -28,34 +28,60 @@ enum class LookupMode
     FromKeeper // send a function from a keeper state to a lane
 };
 
-enum class DeepOp
-{
-    New,
-    Delete,
-    Metatable,
-    Module,
-};
-
-using luaG_IdFunction = void*(*)(lua_State* L, DeepOp op_);
-
 // ################################################################################################
 
 // xxh64 of string "DEEP_VERSION_3" generated at https://www.pelock.com/products/hash-calculator
-static constexpr UniqueKey DEEP_VERSION{ 0xB2CC0FD9C0AE9674ull };
+static constexpr UniqueKey DEEP_VERSION{ 0xB2CC0FD9C0AE9674ull, "DEEP_VERSION_3" };
 
 // should be used as header for deep userdata
 // a deep userdata is a full userdata that stores a single pointer to the actual DeepPrelude-derived object
 struct DeepPrelude
 {
-    UniqueKey const magic{ DEEP_VERSION };
-    // when stored in a keeper state, the full userdata doesn't have a metatable, so we need direct access to the idfunc
-    luaG_IdFunction idfunc { nullptr };
+    UniqueKey const m_magic{ DEEP_VERSION };
+    // when stored in a keeper state, the full userdata doesn't have a metatable, so we need direct access to the factory
+    class DeepFactory& m_factory;
     // data is destroyed when refcount is 0
     std::atomic<int> m_refcount{ 0 };
+
+    DeepPrelude(DeepFactory& factory_)
+    : m_factory{ factory_ }
+    {
+    }
 };
 
-[[nodiscard]] char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
-void free_deep_prelude(lua_State* L, DeepPrelude* prelude_);
+// external C modules should create a single object implementing that interface for each Deep userdata class they want to expose
+class DeepFactory
+{
+    protected:
+
+    // protected non-virtual destructor: Lanes won't manage the Factory's lifetime
+    DeepFactory() = default;
+    ~DeepFactory() = default;
+
+    public:
+
+    // non-copyable, non-movable
+    DeepFactory(DeepFactory const&) = delete;
+    DeepFactory(DeepFactory const&&) = delete;
+    DeepFactory& operator=(DeepFactory const&) = delete;
+    DeepFactory& operator=(DeepFactory const&&) = delete;
+
+    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 char const* moduleName() const = 0;
+
+    public:
+
+    // NVI: public interface
+    int pushDeepUserdata(Dest L, int nuv_) const;
+    DeepPrelude* toDeep(lua_State* L, int index) const;
+    static void DeleteDeepObject(lua_State* L, DeepPrelude* o_);
+    static char const* PushDeepProxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
+};
 
-LANES_API [[nodiscard]] int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_);
-LANES_API [[nodiscard]] DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index);
+//LANES_API [[nodiscard]] int luaG_newdeepuserdata(Dest L, DeepFactory& factory_, int nuv_);
+//LANES_API [[nodiscard]] DeepPrelude* luaG_todeep(lua_State* L, DeepFactory &factory_, int index);