feat: Implement a function to determine if 2 strings of a maximum length are adjacent.

This will be used in a subsequent PR to correctly determine if 2 Bigtable row
keys are adjacent, given that a Bigtable row key must be at most 4KiB
in length.

Author: marete

google/cloud/bigtable/emulator/range_set.cc

@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <cassert>
 #include <chrono>
+#include <iterator>
 #include <ostream>
 #include <string>
 
@@ -573,6 +574,52 @@ std::ostream& operator<<(std::ostream& os,
   return os;
 }
 
+bool ConsecutiveStringsOfMaxLen(std::string const& a, std::string const& b,
+                                std::size_t max_len) {
+  assert(a.length() <= max_len);
+  assert(b.length() <= max_len);
+
+  if (max_len == 0) {
+    return false;
+  }
+
+  if (a.length() < max_len) {
+    return internal::ConsecutiveRowKeys(a, b);
+  }
+
+  // Note that at this point we are guaranteed that a is not empty but
+  // let us be sure.
+  assert(!a.empty());
+
+  // What is the rightmost index that we can increment by 1 to get
+  // the next string in lexicographic order.
+  absl::optional<std::size_t> index_to_inc = absl::nullopt;
+
+  for (auto it = a.rbegin(); it != a.rend(); it++) {
+    char c = *it;
+    if (c < CHAR_MAX) {
+      index_to_inc = (a.length() - 1) - std::distance(a.rbegin(), it);
+      break;
+    }
+  }
+
+  if (!index_to_inc.has_value()) {
+    // a is the last string in lexicographical order for strings of
+    // max_len chars, so it has no successor.
+    return false;
+  }
+
+  std::string successor_to_a;
+  // A copy but if we want we could fix that by a comparison in 3
+  // parts. However, row keys that are at maximum length are the rare
+  // exception, presumably.
+  successor_to_a = a;
+
+  successor_to_a[index_to_inc.value()] += 1;
+
+  return successor_to_a == b;
+}
+
 }  // namespace emulator
 }  // namespace bigtable
 }  // namespace cloud

google/cloud/bigtable/emulator/range_set.h

@@ -191,6 +191,9 @@ bool operator==(TimestampRangeSet::Range const& lhs,
 std::ostream& operator<<(std::ostream& os,
                          TimestampRangeSet::Range const& range);
 
+bool ConsecutiveStringsOfMaxLen(std::string const& a, std::string const& b,
+                                std::size_t max_len);
+
 // For testing only.
 namespace detail {
 

google/cloud/bigtable/emulator/range_set_test.cc

@@ -19,6 +19,7 @@
 #include <gtest/gtest.h>
 #include <algorithm>
 #include <chrono>
+#include <climits>
 #include <iterator>
 #include <set>
 #include <sstream>
@@ -816,6 +817,52 @@ TEST(StringRangeSet, IntersectDistinct) {
   ASSERT_EQ(empty, srs.disjoint_ranges());
 }
 
+TEST(ConsecutiveStringsOfMaxLen, ZeroLen) {
+  std::string a;
+  std::string b;
+
+  ASSERT_FALSE(ConsecutiveStringsOfMaxLen(a, b, 0));
+}
+
+TEST(ConsecutiveStringsOfMaxLen, ShorterThanMaxLen) {
+  std::string a;
+  std::string b;
+  b.push_back('\0');
+
+  ASSERT_TRUE(ConsecutiveStringsOfMaxLen(a, b, 1));
+
+  a = "a";
+  b = "a";
+  b.push_back('\0');
+
+  ASSERT_TRUE(ConsecutiveStringsOfMaxLen(a, b, 2));
+}
+
+TEST(ConsecutiveStringsOfMaxLen, FirstHasMaxLen) {
+  std::string a = "a";
+  std::string b = "b";
+
+  ASSERT_TRUE(ConsecutiveStringsOfMaxLen(a, b, 1));
+
+  a = "a";
+  b = "c";
+
+  ASSERT_FALSE(ConsecutiveStringsOfMaxLen(a, b, 1));
+
+  // Test the case where the first string is at max length and the
+  // terminal char or chars cannot be incremented because they are at
+  // maximum value.
+  a = "a";
+  a.push_back(CHAR_MAX);
+  a.push_back(CHAR_MAX);
+
+  b = "b";
+  b.push_back(CHAR_MAX);
+  b.push_back(CHAR_MAX);
+
+  ASSERT_TRUE(ConsecutiveStringsOfMaxLen(a, b, 3));
+}
+
 }  // anonymous namespace
 }  // namespace emulator
 }  // namespace bigtable