1 files changed, 8 insertions, 31 deletions

diff --git a/src/linda.hpp b/src/linda.hpp
index 01ca7e1..f02c46e 100644
--- a/src/linda.hpp
+++ b/src/linda.hpp
@@ -8,37 +8,12 @@ struct Keeper;
 
 // #################################################################################################
 
-// xxh64 of string "kLindaBatched" generated at https://www.pelock.com/products/hash-calculator
-static constexpr UniqueKey kLindaBatched{ 0xB8234DF772646567ull, "linda.batched" };
-
-// #################################################################################################
-
 DECLARE_UNIQUE_TYPE(LindaGroup, int);
 
 class Linda final
 : public DeepPrelude // Deep userdata MUST start with this header
 {
     public:
-    class [[nodiscard]] KeeperOperationInProgress final
-    {
-        private:
-        Linda& linda;
-        [[maybe_unused]] lua_State* const L; // just here for inspection while debugging
-
-        public:
-        KeeperOperationInProgress(Linda& linda_, lua_State* const L_)
-        : linda{ linda_ }
-        , L{ L_ }
-        {
-            [[maybe_unused]] UnusedInt const _prev{ linda.keeperOperationCount.fetch_add(1, std::memory_order_seq_cst) };
-        }
-
-        public:
-        ~KeeperOperationInProgress()
-        {
-            [[maybe_unused]] UnusedInt const _prev{ linda.keeperOperationCount.fetch_sub(1, std::memory_order_seq_cst) };
-        }
-    };
 
     enum class [[nodiscard]] Status
     {
@@ -47,19 +22,21 @@ class Linda final
     };
     using enum Status;
 
-    private:
+    public:
+    Universe* const U{ nullptr }; // the universe this linda belongs to
 
+    private:
     static constexpr size_t kEmbeddedNameLength = 24;
     using EmbeddedName = std::array<char, kEmbeddedNameLength>;
     // depending on the name length, it is either embedded inside the Linda, or allocated separately
     std::variant<std::string_view, EmbeddedName> nameVariant{};
     // counts the keeper operations in progress
-    std::atomic<int> keeperOperationCount{};
+    mutable std::atomic<int> keeperOperationCount{};
+    lua_Duration wakePeriod{};
 
     public:
     std::condition_variable readHappened{};
     std::condition_variable writeHappened{};
-    Universe* const U{ nullptr }; // the universe this linda belongs to
     KeeperIndex const keeperIndex{ -1 }; // the keeper associated to this linda
     Status cancelStatus{ Status::Active };
 
@@ -73,7 +50,7 @@ class Linda final
     static void operator delete(void* p_) { static_cast<Linda*>(p_)->U->internalAllocator.free(p_, sizeof(Linda)); }
 
     ~Linda();
-    Linda(Universe* U_, LindaGroup group_, std::string_view const& name_);
+    Linda(Universe* U_, std::string_view const& name_, lua_Duration wake_period_, LindaGroup group_);
     Linda() = delete;
     // non-copyable, non-movable
     Linda(Linda const&) = delete;
@@ -97,6 +74,8 @@ class Linda final
     [[nodiscard]]
     std::string_view getName() const;
     [[nodiscard]]
+    auto getWakePeriod() const { return wakePeriod; }
+    [[nodiscard]]
     bool inKeeperOperation() const { return keeperOperationCount.load(std::memory_order_seq_cst) != 0; }
     template <typename T = uintptr_t>
     [[nodiscard]]
@@ -111,7 +90,5 @@ class Linda final
     static int ProtectedCall(lua_State* L_, lua_CFunction f_);
     void pushCancelString(lua_State* L_) const;
     [[nodiscard]]
-    KeeperOperationInProgress startKeeperOperation(lua_State* const L_) { return KeeperOperationInProgress{ *this, L_ }; };
-    [[nodiscard]]
     Keeper* whichKeeper() const { return U->keepers.getKeeper(keeperIndex); }
 };