Internal improvements: new strong types StackIndex and KeeperIndex

8 files changed, 84 insertions, 79 deletions

diff --git a/src/debug.h b/src/debug.h
index e96632d..0f5c6bc 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -2,6 +2,7 @@
 
 #include "lanesconf.h"
 #include "luaerrors.h"
+#include "unique.hpp"
 
 // #################################################################################################
 
@@ -18,7 +19,7 @@ inline SourceLocation Where(std::source_location const& where_ = std::source_loc
     return std::make_tuple(_fileName, where_.line(), _func);
 }
 
-inline void LUA_ASSERT_IMPL(lua_State* const L_, bool cond_, std::string_view const& txt_, SourceLocation const& where_ = Where())
+inline void LUA_ASSERT_IMPL(lua_State* const L_, bool const cond_, std::string_view const& txt_, SourceLocation const& where_ = Where())
 {
     if (!cond_) {
         raise_luaL_error(L_, "%s:%d: LUA_ASSERT '%s' IN %s", std::get<0>(where_).data(), std::get<1>(where_), txt_.data(), std::get<2>(where_).data());
@@ -35,19 +36,8 @@ class StackChecker
     int oldtop;
 
     public:
-    struct Relative
-    {
-        int const offset;
-
-        operator int() const { return offset; }
-    };
-
-    struct Absolute
-    {
-        int const offset;
-
-        operator int() const { return offset; }
-    };
+    using Relative = Unique<int>;
+    using Absolute = Unique<int>;
 
     StackChecker(lua_State* const L_, Relative const offset_, SourceLocation const& where_ = Where())
     : L{ L_ }
@@ -77,7 +67,7 @@ class StackChecker
     }
 
     // verify if the distance between the current top and the initial one is what we expect
-    void check(int expected_, SourceLocation const& where_ = Where())
+    void check(int const expected_, SourceLocation const& where_ = Where())
     {
         if (expected_ != LUA_MULTRET) {
             int const _actual{ lua_gettop(L) - oldtop };
diff --git a/src/keeper.cpp b/src/keeper.cpp
index e2df380..58796b8 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -840,7 +840,7 @@ void Keepers::close()
 
 // #################################################################################################
 
-[[nodiscard]] Keeper* Keepers::getKeeper(int idx_)
+[[nodiscard]] Keeper* Keepers::getKeeper(KeeperIndex const idx_)
 {
     if (isClosing.test(std::memory_order_acquire)) {
         return nullptr;
diff --git a/src/keeper.h b/src/keeper.h
index 05e3547..04bf834 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -9,6 +9,7 @@ class Universe;
 
 using KeeperState = Unique<lua_State*>;
 using LindaLimit = Unique<int>;
+using KeeperIndex = Unique<int>;
 
 // #################################################################################################
 
@@ -62,7 +63,7 @@ struct Keepers
 
     Keepers() = default;
     void close();
-    [[nodiscard]] Keeper* getKeeper(int idx_);
+    [[nodiscard]] Keeper* getKeeper(KeeperIndex idx_);
     [[nodiscard]] int getNbKeepers() const;
     void initialize(Universe& U_, lua_State* L_, int nbKeepers_, int gc_threshold_);
 };
diff --git a/src/linda.cpp b/src/linda.cpp
index eb39c0f..3f5fd33 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -44,10 +44,10 @@ namespace {
     // #############################################################################################
 
 
-    static void CheckKeyTypes(lua_State* const L_, int const start_, int const end_)
+    static void CheckKeyTypes(lua_State* const L_, StackIndex const start_, StackIndex const end_)
     {
         STACK_CHECK_START_REL(L_, 0);
-        for (int const _i : std::ranges::iota_view{ start_, end_ + 1 }) {
+        for (StackIndex const _i : std::ranges::iota_view{ start_, StackIndex{ end_ + 1 } }) {
             LuaType const _t{ luaG_type(L_, _i) };
             switch (_t) {
             case LuaType::BOOLEAN:
@@ -83,7 +83,7 @@ namespace {
     // #############################################################################################
 
     template <bool OPT>
-    [[nodiscard]] static inline Linda* ToLinda(lua_State* const L_, int const idx_)
+    [[nodiscard]] static inline Linda* ToLinda(lua_State* const L_, StackIndex const idx_)
     {
         Linda* const _linda{ static_cast<Linda*>(LindaFactory::Instance.toDeep(L_, idx_)) };
         if constexpr (!OPT) {
@@ -104,7 +104,7 @@ namespace {
      */
 
     template <bool OPT>
-    [[nodiscard]] static int LindaToString(lua_State* const L_, int const idx_)
+    [[nodiscard]] static int LindaToString(lua_State* const L_, StackIndex const idx_)
     {
         Linda* const _linda{ ToLinda<OPT>(L_, idx_) };
         if (_linda != nullptr) {
@@ -192,7 +192,7 @@ std::string_view Linda::getName() const
 // used to perform all linda operations that access keepers
 int Linda::ProtectedCall(lua_State* const L_, lua_CFunction const f_)
 {
-    Linda* const _linda{ ToLinda<false>(L_, 1) };
+    Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
 
     // acquire the keeper
     Keeper* const _keeper{ _linda->acquireKeeper() };
@@ -279,7 +279,7 @@ void Linda::setName(std::string_view const& name_)
  */
 LUAG_FUNC(linda_cancel)
 {
-    Linda* const _linda{ ToLinda<false>(L_, 1) };
+    Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
     std::string_view const _who{ luaG_optstring(L_, 2, "both") };
     // make sure we got 2 arguments: the linda and the cancellation mode
     luaL_argcheck(L_, lua_gettop(L_) <= 2, 2, "wrong number of arguments");
@@ -306,7 +306,7 @@ LUAG_FUNC(linda_cancel)
 // linda:__close(err|nil)
 static LUAG_FUNC(linda_close)
 {
-    [[maybe_unused]] Linda* const _linda{ ToLinda<false>(L_, 1) };                                 // L_: linda err|nil
+    [[maybe_unused]] Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };                   // L_: linda err|nil
 
     // do we have a uservalue? it contains a callback
     switch (lua_getiuservalue(L_, 1, 1)) {
@@ -340,11 +340,11 @@ LUAG_FUNC(linda_concat)
 {                                                                                                  // L_: linda1? linda2?
     bool _atLeastOneLinda{ false };
     // Lua semantics enforce that one of the 2 arguments is a Linda, but not necessarily both.
-    if (LindaToString<true>(L_, 1)) {
+    if (LindaToString<true>(L_, StackIndex{ 1 })) {
         _atLeastOneLinda = true;
         lua_replace(L_, 1);
     }
-    if (LindaToString<true>(L_, 2)) {
+    if (LindaToString<true>(L_, StackIndex{ 2 })) {
         _atLeastOneLinda = true;
         lua_replace(L_, 2);
     }
@@ -366,9 +366,9 @@ LUAG_FUNC(linda_count)
 {
     static constexpr lua_CFunction _count{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             // make sure the keys are of a valid type
-            CheckKeyTypes(L_, 2, lua_gettop(L_));
+            CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ lua_gettop(L_) });
 
             Keeper* const _keeper{ _linda->whichKeeper() };
             KeeperCallResult const _pushed{ keeper_call(_keeper->K, KEEPER_API(count), L_, _linda, 2) };
@@ -392,7 +392,7 @@ LUAG_FUNC(linda_count)
  */
 LUAG_FUNC(linda_deep)
 {
-    Linda* const _linda{ ToLinda<false>(L_, 1) };
+    Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
     lua_pushlightuserdata(L_, _linda->obfuscated<void*>()); // just the address
     return 1;
 }
@@ -407,7 +407,7 @@ LUAG_FUNC(linda_dump)
 {
     static constexpr lua_CFunction _dump{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             return Keeper::PushLindaStorage(*_linda, DestState{ L_ });
         }
     };
@@ -425,12 +425,12 @@ LUAG_FUNC(linda_get)
 {
     static constexpr lua_CFunction _get{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             lua_Integer const _count{ luaL_optinteger(L_, 3, 1) };
             luaL_argcheck(L_, _count >= 1, 3, "count should be >= 1");
             luaL_argcheck(L_, lua_gettop(L_) <= 3, 4, "too many arguments");
             // make sure the key is of a valid type (throws an error if not the case)
-            CheckKeyTypes(L_, 2, 2);
+            CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
@@ -463,7 +463,7 @@ LUAG_FUNC(linda_limit)
 {
     static constexpr lua_CFunction _limit{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             // make sure we got 2 or 3 arguments: the linda, a key and optionally a limit
             int const _nargs{ lua_gettop(L_) };
             luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
@@ -474,7 +474,7 @@ LUAG_FUNC(linda_limit)
                 raise_luaL_argerror(L_, 3, "limit must be >= 0");
             }
             // make sure the key is of a valid type
-            CheckKeyTypes(L_, 2, 2);
+            CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
@@ -526,8 +526,8 @@ LUAG_FUNC(linda_receive)
 {
     static constexpr lua_CFunction _receive{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
-            int _key_i{ 2 }; // index of first key, if timeout not there
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
+            StackIndex _key_i{ 2 }; // index of first key, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
             if (luaG_type(L_, 2) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
@@ -566,7 +566,7 @@ LUAG_FUNC(linda_receive)
                 }
             } else {
                 // make sure the keys are of a valid type
-                CheckKeyTypes(L_, _key_i, lua_gettop(L_));
+                CheckKeyTypes(L_, _key_i, StackIndex{ lua_gettop(L_) });
                 // receive a single value, checking multiple slots
                 _selected_keeper_receive = KEEPER_API(receive);
                 // we expect a single (value, key) pair of returned values
@@ -682,8 +682,8 @@ LUAG_FUNC(linda_send)
 {
     static constexpr lua_CFunction _send{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
-            int _key_i{ 2 }; // index of first key, if timeout not there
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
+            StackIndex _key_i{ 2 }; // index of first key, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
             if (luaG_type(L_, 2) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
@@ -820,10 +820,10 @@ LUAG_FUNC(linda_set)
 {
     static constexpr lua_CFunction _set{
         +[](lua_State* const L_) {
-            Linda* const _linda{ ToLinda<false>(L_, 1) };
+            Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
             bool const _has_data{ lua_gettop(L_) > 2 };
             // make sure the key is of a valid type (throws an error if not the case)
-            CheckKeyTypes(L_, 2, 2);
+            CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
 
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
@@ -859,7 +859,7 @@ LUAG_FUNC(linda_set)
 
 LUAG_FUNC(linda_tostring)
 {
-    return LindaToString<false>(L_, 1);
+    return LindaToString<false>(L_, StackIndex{ 1 });
 }
 
 // #################################################################################################
@@ -871,11 +871,11 @@ LUAG_FUNC(linda_tostring)
  */
 LUAG_FUNC(linda_towatch)
 {
-    Linda* const _linda{ ToLinda<false>(L_, 1) };
+    Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
     int _pushed{ Keeper::PushLindaStorage(*_linda, DestState{ L_ }) };
     if (_pushed == 0) {
         // if the linda is empty, don't return nil
-        _pushed = LindaToString<false>(L_, 1);
+        _pushed = LindaToString<false>(L_, StackIndex{ 1 });
     }
     return _pushed;
 }
@@ -989,7 +989,7 @@ LUAG_FUNC(linda)
         }
         // depending on whether we have a handler or not, the stack is not in the same state at this point
         // just make sure we have our Linda at the top
-        LUA_ASSERT(L_, ToLinda<true>(L_, -1));
+        LUA_ASSERT(L_, ToLinda<true>(L_, StackIndex{ -1 }));
         return 1;
     } else { // no to-be-closed support
         // ensure we have name, group in that order on the stack
diff --git a/src/linda.h b/src/linda.h
index 6901a86..4551443 100644
--- a/src/linda.h
+++ b/src/linda.h
@@ -52,7 +52,7 @@ class Linda
     std::condition_variable readHappened{};
     std::condition_variable writeHappened{};
     Universe* const U{ nullptr }; // the universe this linda belongs to
-    int const keeperIndex{ -1 }; // the keeper associated to this linda
+    KeeperIndex const keeperIndex{ -1 }; // the keeper associated to this linda
     CancelRequest cancelRequest{ CancelRequest::None };
 
     public:
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index 1b1ced6..e73abef 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -2,6 +2,7 @@
 
 #include "debug.h"
 #include "luaerrors.h"
+#include "unique.hpp"
 
 using namespace std::chrono_literals;
 
@@ -24,40 +25,9 @@ using lua_Duration = std::chrono::template duration<lua_Number>;
 
 // #################################################################################################
 
-// A unique type generator
-template <typename T, auto = [] {}, typename specialization = void>
-class Unique
-{
-    private:
-    T val;
-
-    public:
-    using type = T;
-    Unique() = default;
-    operator T() const { return val; }
-    explicit Unique(T b_)
-    : val{ b_ }
-    {
-    }
-};
-
-template <typename T, auto lambda>
-class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>>
-: public T
-{
-    public:
-    using type = T;
-    using T::T;
-    explicit Unique(T const& b_)
-    : T{ b_ }
-    {
-    }
-};
-
-// #################################################################################################
-
 using SourceState = Unique<lua_State*>;
 using DestState = Unique<lua_State*>;
+using StackIndex = Unique<int>;
 
 // #################################################################################################
 
diff --git a/src/unique.hpp b/src/unique.hpp
new file mode 100644
index 0000000..aeb7a67
--- /dev/null
+++ b/src/unique.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+// #################################################################################################
+
+// A unique type generator
+template <typename T, auto = [] {}, typename specialization = void>
+class Unique
+{
+    private:
+    T val;
+
+    public:
+    using type = T;
+    Unique() = default;
+    operator T() const { return val; }
+    explicit Unique(T b_)
+    : val{ b_ }
+    {
+    }
+    // pre-imcrement
+    auto& operator++()
+    {
+        ++val;
+        return *this;
+    }
+    // post-increment
+    auto operator++(int)
+    {
+        return Unique<T>{ std::exchange(val, val + 1) };
+    }
+};
+
+template <typename T, auto lambda>
+class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>>
+: public T
+{
+    public:
+    using type = T;
+    using T::T;
+    explicit Unique(T const& b_)
+    : T{ b_ }
+    {
+    }
+};
diff --git a/src/universe.cpp b/src/universe.cpp
index 04db10f..3800dbb 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -85,7 +85,7 @@ void Universe::callOnStateCreate(lua_State* const L_, lua_State* const from_, Lo
     }
 
     STACK_CHECK_START_REL(L_, 0);
-    DEBUGSPEW_CODE(DebugSpew(U_) << "calling on_state_create()" << std::endl);
+    DEBUGSPEW_CODE(DebugSpew(this) << "calling on_state_create()" << std::endl);
     if (std::holds_alternative<lua_CFunction>(onStateCreateFunc)) {
             
         // C function: recreate a closure in the new state, bypassing the lookup scheme