Internal rework of an enum bad practice usage

7 files changed, 106 insertions, 107 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index 31656c4..73ee6f3 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -81,25 +81,24 @@ CancelRequest CheckCancelRequest(lua_State* const L_)
 // #################################################################################################
 // #################################################################################################
 
-CancelOp WhichCancelOp(std::string_view const& opString_)
+static std::optional<CancelOp> WhichCancelOp(std::string_view const& opString_)
 {
-    auto _op{ CancelOp::Invalid };
-    if (opString_ == "hard") {
-        _op = CancelOp::Hard;
-    } else if (opString_ == "soft") {
-        _op = CancelOp::Soft;
+    if (opString_ == "soft") {
+        return std::make_optional<CancelOp>(CancelRequest::Soft, LuaHookMask::None);
+    } else if (opString_ == "hard") {
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::None);
     } else if (opString_== "call") {
-        _op = CancelOp::MaskCall;
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Call);
     } else if (opString_ == "ret") {
-        _op = CancelOp::MaskRet;
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Ret);
     } else if (opString_ == "line") {
-        _op = CancelOp::MaskLine;
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Line);
     } else if (opString_ == "count") {
-        _op = CancelOp::MaskCount;
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::Count);
     } else if (opString_ == "all") {
-        _op = CancelOp::MaskAll;
+        return std::make_optional<CancelOp>(CancelRequest::Hard, LuaHookMask::All);
     }
-    return _op;
+    return std::nullopt;
 }
 
 // #################################################################################################
@@ -109,14 +108,14 @@ static CancelOp WhichCancelOp(lua_State* const L_, StackIndex const idx_)
 {
     if (luaG_type(L_, idx_) == LuaType::STRING) {
         std::string_view const _str{ luaG_tostring(L_, idx_) };
-        CancelOp _op{ WhichCancelOp(_str) };
+        auto const _op{ WhichCancelOp(_str) };
         lua_remove(L_, idx_); // argument is processed, remove it
-        if (_op == CancelOp::Invalid) {
-            raise_luaL_error(L_, "invalid hook option %s", _str.data());
+        if (!_op.has_value()) {
+            raise_luaL_error(L_, "Invalid cancel option %s", _str.data());
         }
-        return _op;
+        return _op.value();
     }
-    return CancelOp::Hard;
+    return CancelOp{ CancelRequest::Hard, LuaHookMask::None };
 }
 
 // #################################################################################################
@@ -133,7 +132,7 @@ static CancelOp WhichCancelOp(lua_State* const L_, StackIndex const idx_)
 //
 LUAG_FUNC(cancel_test)
 {
-    CancelRequest _test{ CheckCancelRequest(L_) };
+    CancelRequest const _test{ CheckCancelRequest(L_) };
     lua_pushboolean(L_, _test != CancelRequest::None);
     return 1;
 }
@@ -146,14 +145,17 @@ LUAG_FUNC(lane_cancel)
     Lane* const _lane{ ToLane(L_, StackIndex{ 1 }) };
     CancelOp const _op{ WhichCancelOp(L_, StackIndex{ 2 }) }; // this removes the cancel_op string from the stack
 
-    int _hook_count{ 0 };
-    if (_op > CancelOp::Soft) { // hook is requested
-        _hook_count = static_cast<int>(luaL_checkinteger(L_, 2));
+    int const _hook_count = std::invoke([_op, L_]() {
+        if (_op.hookMask == LuaHookMask::None) {
+            return 0;
+        }
+        auto const _hook_count{ static_cast<int>(luaL_checkinteger(L_, 2)) };
         lua_remove(L_, 2); // argument is processed, remove it
         if (_hook_count < 1) {
-            raise_luaL_error(L_, "hook count cannot be < 1");
+            raise_luaL_error(L_, "Hook count cannot be < 1");
         }
-    }
+        return _hook_count;
+    });
 
     std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
     if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
@@ -169,7 +171,7 @@ LUAG_FUNC(lane_cancel)
     }
 
     // we wake by default in "hard" mode (remember that hook is hard too), but this can be turned off if desired
-    WakeLane _wake_lane{ _op != CancelOp::Soft ? WakeLane::Yes : WakeLane::No };
+    WakeLane _wake_lane{ (_op.mode == CancelRequest::Hard) ? WakeLane::Yes : WakeLane::No };
     if (lua_gettop(L_) >= 2) {
         if (!lua_isboolean(L_, 2)) {
             raise_luaL_error(L_, "wake_lane argument is not a boolean");
diff --git a/src/cancel.hpp b/src/cancel.hpp
index 8f4cf07..65ccf8d 100644
--- a/src/cancel.hpp
+++ b/src/cancel.hpp
@@ -6,36 +6,25 @@
 // #################################################################################################
 
 // Lane cancellation request modes
-enum class CancelRequest
+enum class CancelRequest : uint8_t
 {
     None, // no pending cancel request
     Soft, // user wants the lane to cancel itself manually on cancel_test()
     Hard // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
 };
 
-enum class CancelResult
+struct CancelOp
 {
-    Timeout,
-    Cancelled
+    CancelRequest mode;
+    LuaHookMask hookMask;
 };
 
-enum class CancelOp
+enum class CancelResult : uint8_t
 {
-    Invalid = -2,
-    Hard = -1,
-    Soft = 0,
-    MaskCall = LUA_MASKCALL,
-    MaskRet = LUA_MASKRET,
-    MaskLine = LUA_MASKLINE,
-    MaskCount = LUA_MASKCOUNT,
-    MaskAll = LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT
+    Timeout,
+    Cancelled
 };
 
-inline auto operator<=>(CancelOp const a_, CancelOp const b_)
-{
-    return static_cast<std::underlying_type_t<CancelOp>>(a_) <=> static_cast<std::underlying_type_t<CancelOp>>(b_);
-}
-
 // xxh64 of string "kCancelError" generated at https://www.pelock.com/products/hash-calculator
 static constexpr UniqueKey kCancelError{ 0x0630345FEF912746ull, "lanes.cancel_error" }; // 'raise_cancel_error' sentinel
 
@@ -43,8 +32,6 @@ static constexpr UniqueKey kCancelError{ 0x0630345FEF912746ull, "lanes.cancel_er
 
 [[nodiscard]]
 CancelRequest CheckCancelRequest(lua_State* L_);
-[[nodiscard]]
-CancelOp WhichCancelOp(std::string_view const& opString_);
 
 // #################################################################################################
 
diff --git a/src/compat.hpp b/src/compat.hpp
index 81f1665..80bc391 100644
--- a/src/compat.hpp
+++ b/src/compat.hpp
@@ -49,6 +49,16 @@ enum class LuaType
     CDATA = 10 // LuaJIT CDATA
 };
 
+enum class LuaHookMask
+{
+    None = 0,
+    Call = LUA_MASKCALL,
+    Ret = LUA_MASKRET,
+    Line = LUA_MASKLINE,
+    Count = LUA_MASKCOUNT,
+    All = LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT
+};
+
 // #################################################################################################
 
 // add some Lua 5.3-style API when building for Lua 5.1
diff --git a/src/lane.cpp b/src/lane.cpp
index 923eabd..9ab574e 100644
--- a/src/lane.cpp
+++ b/src/lane.cpp
@@ -930,10 +930,10 @@ CancelResult Lane::cancel(CancelOp const op_, std::chrono::time_point<std::chron
 
     // signal the linda to wake up the thread so that it can react to the cancel query
     // let us hope we never land here with a pointer on a linda that has been destroyed...
-    if (op_ == CancelOp::Soft) {
+    if (op_.mode == CancelRequest::Soft) {
         return internalCancel(CancelRequest::Soft, until_, wakeLane_);
-    } else if (op_ > CancelOp::Soft) {
-        lua_sethook(L, _cancelHook, static_cast<int>(op_), hookCount_);
+    } else if (op_.hookMask != LuaHookMask::None) {
+        lua_sethook(L, _cancelHook, static_cast<int>(op_.hookMask), hookCount_);
     }
 
     return internalCancel(CancelRequest::Hard, until_, wakeLane_);
diff --git a/src/universe.cpp b/src/universe.cpp
index eab5977..ec7d043 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -417,9 +417,9 @@ LUAG_FUNC(universe_gc)
 
     // attempt to terminate all lanes with increasingly stronger cancel methods
     bool const _allLanesTerminated{ 
-        _U->terminateFreeRunningLanes(_shutdown_timeout, CancelOp::Soft)
-        || _U->terminateFreeRunningLanes(_shutdown_timeout, CancelOp::Hard)
-        || _U->terminateFreeRunningLanes(_shutdown_timeout, CancelOp::MaskAll)
+        _U->terminateFreeRunningLanes(_shutdown_timeout, { CancelRequest::Soft, LuaHookMask::None })
+        || _U->terminateFreeRunningLanes(_shutdown_timeout, { CancelRequest::Hard, LuaHookMask::None })
+        || _U->terminateFreeRunningLanes(_shutdown_timeout, { CancelRequest::Hard, LuaHookMask::All })
     };
 
     // invoke the function installed by lanes.finally()
diff --git a/src/universe.hpp b/src/universe.hpp
index fa1e238..639dcdb 100644
--- a/src/universe.hpp
+++ b/src/universe.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "allocator.hpp"
+#include "cancel.hpp"
 #include "keeper.hpp"
 #include "lanesconf.h"
 #include "tracker.hpp"
@@ -9,7 +10,6 @@
 // #################################################################################################
 
 // forwards
-enum class CancelOp;
 struct DeepPrelude;
 class Lane;
 
diff --git a/tests/cancel.lua b/tests/cancel.lua
index e65d794..9b65ad3 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -24,7 +24,7 @@ end
 
 local linda = lanes.linda()
 -- a numeric value to read
-linda:set( "val", 33.0)
+linda:set("val", 33.0)
 
 -- so that we can easily swap between lanes.gen and lanes.coro, to try stuff
 local generator = lanes.coro
@@ -36,27 +36,27 @@ if not next(which_tests) or which_tests.genlock then
         print "\n\n####################################################################\nbegin genlock & genatomic cancel test\n"
 
         -- get a lock and a atomic operator
-        local lock = lanes.genlock( linda, "lock", 1)
-        local atomic = lanes.genatomic( linda, "atomic")
+        local lock = lanes.genlock(linda, "lock", 1)
+        local atomic = lanes.genatomic(linda, "atomic")
 
         local check_returned_cancel_error = function(_status, _err)
                 assert(_status == nil and _err == lanes.cancel_error)
         end
         -- check that cancelled lindas give cancel_error as they should
         linda:cancel()
-        check_returned_cancel_error(linda:set( "empty", 42))
-        check_returned_cancel_error(linda:get( "empty"))
-        check_returned_cancel_error(linda:send( "empty", 42))
-        check_returned_cancel_error(linda:receive( "empty"))
-        check_returned_cancel_error(linda:limit( "empty", 5))
-        check_returned_cancel_error(linda:restrict( "empty", "set/get"))
-        assert( lanes.genlock( linda, "any", 1) == lanes.cancel_error)
-        assert( lanes.genatomic( linda, "any") == lanes.cancel_error)
+        check_returned_cancel_error(linda:set("empty", 42))
+        check_returned_cancel_error(linda:get("empty"))
+        check_returned_cancel_error(linda:send("empty", 42))
+        check_returned_cancel_error(linda:receive("empty"))
+        check_returned_cancel_error(linda:limit("empty", 5))
+        check_returned_cancel_error(linda:restrict("empty", "set/get"))
+        assert(lanes.genlock(linda, "any", 1) == lanes.cancel_error)
+        assert(lanes.genatomic(linda, "any") == lanes.cancel_error)
 
         -- check that lock and atomic functions return cancel_error if the linda was cancelled
-        assert( lock( 1) == lanes.cancel_error)
-        assert( lock( -1) == lanes.cancel_error)
-        assert( atomic( 1) == lanes.cancel_error)
+        assert(lock(1) == lanes.cancel_error)
+        assert(lock(-1) == lanes.cancel_error)
+        assert(atomic(1) == lanes.cancel_error)
 
         -- reset the linda so that the other tests work
         linda:cancel("none")
@@ -70,62 +70,62 @@ end
 
 -- ##################################################################################################
 
-local waitCancellation = function( h, expected_status)
+local waitCancellation = function(h, expected_status)
         local l = lanes.linda()
         if expected_status ~= "running" then
                 repeat
-                        -- print( "lane status:", h.status)
+                        -- print("lane status:", h.status)
                         SLEEP(0.1) -- wait a bit
                 until h.status ~= "running"
         end
-        print( "lane status:", h.status)
-        assert( h.status == expected_status, "lane status " .. h.status .. " (actual) ~= " .. expected_status .. " (expected)")
+        print("lane status:", h.status)
+        assert(h.status == expected_status, "lane status " .. h.status .. " (actual) ~= " .. expected_status .. " (expected)")
         print "test OK"
 end
 
-local laneBody = function( mode_, payload_)
+local laneBody = function(mode_, payload_)
         local name = "laneBody("..tostring(mode_)..","..tostring(payload_)..")"
         lane_threadname(name)
 
-        set_finalizer( function( err, stk)
+        set_finalizer(function(err, stk)
                 if err == lanes.cancel_error then
                         -- note that we don't get the cancel_error when running wrapped inside a protected call if it doesn't rethrow it
-                        print( "                        laneBody after cancel" )
+                        print("                 laneBody after cancel" )
                 elseif err then
-                        print( "                        laneBody error: "..tostring(err))
+                        print("                 laneBody error: "..tostring(err))
                 else
                         print("                 laneBody finalized")
                 end
         end)
 
-        print( "                        entering " , name)
+        print("                 entering " , name)
         repeat
                 if mode_ == "receive" then
                         -- linda mode
-                        io.stdout:write( "                      lane calling receive() ... ")
-                        local key, val = linda:receive( payload_, "boob")
+                        io.stdout:write("                       lane calling receive() ... ")
+                        local key, val = linda:receive(payload_, "boob")
                         print(tostring(key), val == lanes.cancel_error and "cancel_error" or tostring(val))
                         if val == lanes.cancel_error then
                                 break -- gracefully abort loop
                         end
                 elseif mode_ == "get" then
                         -- busy wait mode getting data from the linda
-                        io.stdout:write( "                      lane busy waiting ... ")
+                        io.stdout:write("                       lane busy waiting ... ")
                         for i = 1, payload_ do
                                 -- force a non-jitable call
-                                local _, a = linda:get( "val")
+                                local _, a = linda:get("val")
                                 a = a * 2
                         end
-                        print( "again?")
+                        print("again?")
                 elseif mode_ == "busy" then
                         -- busy wait mode in pure Lua code
-                        io.stdout:write( "                      lane busy waiting ... ")
-                        local _, a = linda:get( "val")
+                        io.stdout:write("                       lane busy waiting ... ")
+                        local _, a = linda:get("val")
                         for i = 1, payload_ do
                                 a = a * 2
-                                a = math.sin( a) * math.sin( a) + math.cos( a) * math.cos( a) -- aka 1
+                                a = math.sin(a) * math.sin(a) + math.cos(a) * math.cos(a) -- aka 1
                         end
-                        print( "again?")
+                        print("again?")
                 else
                         error "no mode: raise an error"
                 end
@@ -133,23 +133,23 @@ local laneBody = function( mode_, payload_)
         print "                 lane shutting down after breaking out of loop"
 end
 
-local protectedBody = function( ...)
+local protectedBody = function(...)
         local ce = lanes.cancel_error
-        local errorHandler = function( _msg)
+        local errorHandler = function(_msg)
                 -- forward the message to the main thread that will display it with a popup
-                print( "                        error handler got ", ce == _msg and "cancel_error"or tostring( _msg))
+                print("                 error handler got ", ce == _msg and "cancel_error" or tostring(_msg))
                 return _msg
         end
         -- Lua 5.1 doesn't pass additional xpcall arguments to the called function
         -- therefore we need to create a closure that has no arguments but pulls everything from its upvalue
         local params = {...}
         local unpack = table.unpack or unpack -- unpack for 5.1, table.unpack for 5.2+
-        local paramLessClosure = function() laneBody(unpack( params)) end
-        local status, message = xpcall( paramLessClosure, errorHandler)
+        local paramLessClosure = function() laneBody(unpack(params)) end
+        local status, message = xpcall(paramLessClosure, errorHandler)
         if status == false then
-                print( "                        error handler rethrowing '" .. (ce == message and "cancel_error"or tostring( message)) .. "'")
+                print("                 error handler rethrowing '" .. (ce == message and "cancel_error"or tostring(message)) .. "'")
                 -- if the error isn't rethrown, the lane's finalizer won't get it
-                error( message)
+                error(message)
         end
 end
 
@@ -159,20 +159,20 @@ end
 if not next(which_tests) or which_tests.linda then
         remaining_tests.linda = nil
         print "\n\n####################################################################\nbegin linda cancel test\n"
-        h = generator( "*", laneBody)( "receive", nil) -- start an infinite wait on the linda
+        h = generator("*", laneBody)("receive", nil) -- start an infinite wait on the linda
 
         print "wait 1s"
         SLEEP(1)
 
         -- linda cancel: linda:receive() returns nil,cancel_error immediately
         print "cancelling"
-        linda:cancel( "both")
+        linda:cancel("both")
 
         -- wait until cancellation is effective.
-        waitCancellation( h, "done")
+        waitCancellation(h, "done")
 
         -- reset the linda so that the other tests work
-        linda:cancel( "none")
+        linda:cancel("none")
 end
 
 -- ##################################################################################################
@@ -180,23 +180,23 @@ end
 if not next(which_tests) or which_tests.soft then
         remaining_tests.soft = nil
         print "\n\n####################################################################\nbegin soft cancel test\n"
-        h = generator( "*", protectedBody)( "receive") -- start an infinite wait on the linda
+        h = generator("*", protectedBody)("receive") -- start an infinite wait on the linda
 
         print "wait 1s"
         SLEEP(1)
 
         -- soft cancel, no awakening of waiting linda operations, should timeout
-        local a, b = h:cancel( "soft", 1, false)
+        local a, b = h:cancel("soft", 1, false)
         -- cancellation should fail as the lane is still waiting on its linda
-        assert( a == false and b == "timeout")
-        waitCancellation( h, "waiting")
+        assert(a == false and b == "timeout")
+        waitCancellation(h, "waiting")
 
         -- soft cancel, this time awakens waiting linda operations, which returns cancel_error immediately, no timeout.
         print "cancelling"
-        h:cancel( "soft", true)
+        h:cancel("soft", true)
 
         -- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
-        waitCancellation( h, "done")
+        waitCancellation(h, "done")
 end
 
 -- ##################################################################################################
@@ -204,16 +204,16 @@ end
 if not next(which_tests) or which_tests.hook then
         remaining_tests.hook = nil
         print "\n\n####################################################################\nbegin hook cancel test\n"
-        h = generator( "*", protectedBody)( "get", 300000)
+        h = generator("*", protectedBody)("get", 300000)
         print "wait 2s"
         SLEEP(2)
 
         -- count hook cancel after some instruction instructions
         print "cancelling"
-        h:cancel( "line", 300, 5.0)
+        h:cancel("line", 300, 5.0)
 
         -- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
-        waitCancellation( h, "cancelled")
+        waitCancellation(h, "cancelled")
 end
 
 -- ##################################################################################################
@@ -221,7 +221,7 @@ end
 if not next(which_tests) or which_tests.hard then
         remaining_tests.hard = nil
         print "\n\n####################################################################\nbegin hard cancel test\n"
-        h = lanes.gen( "*", protectedBody)( "receive", nil) -- infinite timeout
+        h = lanes.gen("*", protectedBody)("receive", nil) -- infinite timeout
 
         -- wait 2s before cancelling the lane
         print "wait 2s"
@@ -232,7 +232,7 @@ if not next(which_tests) or which_tests.hard then
         h:cancel()
 
         -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-        waitCancellation( h, "cancelled")
+        waitCancellation(h, "cancelled")
 end
 
 -- ##################################################################################################
@@ -240,7 +240,7 @@ end
 if not next(which_tests) or which_tests.hard_unprotected then
         remaining_tests.hard_unprotected = nil
         print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
-        h = generator( "*", laneBody)( "receive", nil)
+        h = generator("*", laneBody)("receive", nil)
 
         -- wait 2s before cancelling the lane
         print "wait 2s"
@@ -251,7 +251,7 @@ if not next(which_tests) or which_tests.hard_unprotected then
         h:cancel()
 
         -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-        waitCancellation( h, "cancelled")
+        waitCancellation(h, "cancelled")
 end
 
 -- ##################################################################################################