CheckRangeRightSide struct

ConflictSet.cpp

@@ -1082,32 +1082,52 @@ struct CheckRangeLeftSide {
 
 // Return true if the max version among all keys that start with key[:prefixLen]
 // that are < key is <= readVersion
-bool checkRangeRightSide(Node *n, std::span<const uint8_t> key, int prefixLen,
-                         int64_t readVersion) {
+struct CheckRangeRightSide {
+  CheckRangeRightSide(Node *n, std::span<const uint8_t> key, int prefixLen,
+                      int64_t readVersion)
+      : n(n), key(key), remaining(key), prefixLen(prefixLen),
+        readVersion(readVersion) {
 #if DEBUG_VERBOSE && !defined(NDEBUG)
     fprintf(stderr, "Check range right side to %s for keys starting with %s\n",
-          printable(key).c_str(), printable(key.subspan(0, prefixLen)).c_str());
+            printable(key).c_str(),
+            printable(key.subspan(0, prefixLen)).c_str());
 #endif
-  auto remaining = key;
+  }
+
+  Node *n;
+  std::span<const uint8_t> key;
+  std::span<const uint8_t> remaining;
+  int prefixLen;
+  int64_t readVersion;
   int searchPathLen = 0;
-  for (;;) {
+  bool ok;
+
+  enum Phase { Search, DownLeftSpine } phase = Search;
+
+  bool step() {
+    switch (phase) {
+    case Search: {
       if (n->maxVersion <= readVersion) {
+        ok = true;
         return true;
       }
       if (remaining.size() == 0) {
         assert(searchPathLen >= prefixLen);
+        ok = true;
         return true;
       }
 
       if (searchPathLen >= prefixLen) {
         if (maxBetweenExclusive(n, -1, remaining[0]) > readVersion) {
-        return false;
+          ok = false;
+          return true;
         }
       }
 
       if (searchPathLen >= prefixLen && searchPathLen < int(key.size()) &&
           n->entryPresent && n->entry.pointVersion > readVersion) {
-      return false;
+        ok = false;
+        return true;
       }
 
       int c = getChildGeq(n, remaining[0]);
@@ -1119,15 +1139,19 @@ bool checkRangeRightSide(Node *n, std::span<const uint8_t> key, int prefixLen,
         if (c >= 0) {
           if (searchPathLen < prefixLen) {
             n = getChildExists(n, c);
-          goto downLeftSpine;
-        }
-        if (maxBetweenExclusive(n, -1, c) > readVersion) {
+            phase = DownLeftSpine;
             return false;
           }
+          if (maxBetweenExclusive(n, -1, c) > readVersion) {
+            ok = false;
+            return true;
+          }
+          ok = true;
           return true;
         } else {
           n = nextSibling(n);
-        goto downLeftSpine;
+          phase = DownLeftSpine;
+          return false;
         }
       }
 
@@ -1141,47 +1165,62 @@ bool checkRangeRightSide(Node *n, std::span<const uint8_t> key, int prefixLen,
           }
           if (c > 0) {
             if (searchPathLen < prefixLen) {
-            goto downLeftSpine;
-          }
-          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+              phase = DownLeftSpine;
               return false;
             }
+            if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+              ok = false;
+              return true;
+            }
+            ok = true;
             return true;
           } else {
             if (searchPathLen >= prefixLen && n->maxVersion > readVersion) {
-            return false;
+              ok = false;
+              return true;
             }
             n = nextSibling(n);
-          goto downLeftSpine;
+            phase = DownLeftSpine;
+            return false;
           }
         }
         if (commonLen == n->partialKeyLen) {
           // partial key matches
-        remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
+          remaining =
+              remaining.subspan(commonLen, remaining.size() - commonLen);
         } else if (n->partialKeyLen > int(remaining.size())) {
           if (searchPathLen < prefixLen) {
-          goto downLeftSpine;
-        }
-        if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+            phase = DownLeftSpine;
             return false;
           }
+          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+            ok = false;
+            return true;
+          }
+          ok = true;
           return true;
         }
       }
-  }
-downLeftSpine:
+    } break;
+    case DownLeftSpine:
       if (n == nullptr) {
+        ok = true;
         return true;
       }
       for (;;) {
         if (n->entryPresent) {
-      return n->entry.rangeVersion <= readVersion;
+          ok = n->entry.rangeVersion <= readVersion;
+          return true;
         }
         int c = getChildGeq(n, 0);
         assert(c >= 0);
         n = getChildExists(n, c);
       }
-}
+      break;
+    }
+    return false;
+  }
+};
 
 bool checkRangeRead(Node *n, std::span<const uint8_t> begin,
                     std::span<const uint8_t> end, int64_t readVersion) {
@@ -1238,7 +1277,11 @@ bool checkRangeRead(Node *n, std::span<const uint8_t> begin,
     return false;
   }
 
-  if (!checkRangeRightSide(n, end, lcp + 1, readVersion)) {
+  CheckRangeRightSide checkRangeRightSide{n, end, lcp + 1, readVersion};
+  while (!checkRangeRightSide.step())
+    ;
+
+  if (!checkRangeRightSide.ok) {
     return false;
   }