refactor: search options struct

Author: benthevining

libbenbot/include/libbenbot/search/Options.hpp

@@ -66,7 +66,7 @@ struct Options final {
     /** Search only this many nodes. Setting this value too low can
         really emphasize the effects of our move ordering algorithm.
      */
-    std::optional<size_t> maxNodes;
+    size_t maxNodes { std::numeric_limits<size_t>::max() };
 
     /** Restrict the search to only these moves.
         If this is empty, all legal moves in the position will be searched.

libbenbot/src/search/Options.cpp

@@ -17,6 +17,7 @@
 #include <cstddef> // IWYU pragma: keep - for size_t
 #include <libbenbot/search/Options.hpp>
 #include <libchess/uci/CommandParsing.hpp>
+#include <limits>
 #include <optional>
 
 namespace ben_bot::search {
@@ -47,35 +48,33 @@ namespace {
 void Options::update_from(const chess::uci::GoCommandOptions& goOptions)
 {
     movesToSearch = goOptions.moves;
-    maxNodes      = goOptions.nodes;
     infinite      = goOptions.infinite;
     mateIn        = goOptions.mateIn;
 
-    if (goOptions.depth.has_value())
-        depth = *goOptions.depth;
+    static constexpr auto MAX = std::numeric_limits<size_t>::max();
 
-    // search time
-    if (goOptions.searchTime.has_value()) {
-        searchTime = goOptions.searchTime;
-    } else if (goOptions.infinite) {
-        searchTime = std::nullopt;
-    } else {
-        const bool isWhite = position.is_white_to_move();
+    depth    = goOptions.depth.value_or(MAX);
+    maxNodes = goOptions.nodes.value_or(MAX);
 
-        const auto& timeLeft = isWhite ? goOptions.whiteTimeLeft : goOptions.blackTimeLeft;
+    searchTime = goOptions.searchTime
+                     .or_else([&goOptions, isWhite = position.is_white_to_move()]() -> std::optional<milliseconds> {
+                         if (not goOptions.infinite) {
+                             const auto& timeLeft = isWhite ? goOptions.whiteTimeLeft : goOptions.blackTimeLeft;
 
-        // need to know at least our time remaining in order to calculate search time limit
-        if (timeLeft.has_value()) {
-            searchTime = determine_search_time(
-                *timeLeft,
-                isWhite ? goOptions.whiteInc : goOptions.blackInc,
-                goOptions.movesToGo);
-        }
-    }
+                             // need to know at least our time remaining in order to calculate search time limit
+                             if (timeLeft.has_value()) {
+                                 return determine_search_time(
+                                     *timeLeft,
+                                     isWhite ? goOptions.whiteInc : goOptions.blackInc,
+                                     goOptions.movesToGo);
+                             }
+                         }
 
-    searchTime = searchTime.and_then([overhead = moveOverhead](const milliseconds time) {
-        return std::optional { time - overhead };
-    });
+                         return std::nullopt;
+                     })
+                     .transform([overhead = moveOverhead](const milliseconds time) {
+                         return time - overhead;
+                     });
 }
 
 } // namespace ben_bot::search

libbenbot/src/search/Search.cpp

@@ -345,10 +345,8 @@ void Context::search() // NOLINT(readability-function-cognitive-complexity)
             }
 
             // if we've hit our node limit, don't do a deeper iteration
-            if (options.maxNodes.has_value()
-                and stats.nodesSearched >= *options.maxNodes) {
+            if (stats.nodesSearched >= options.maxNodes)
                 break;
-            }
 
             // if the iteration we just completed took as much or more time than we
             // have remaining for the search, then don't start a deeper iteration