No public description

PiperOrigin-RevId: 942390014

Author: CEL Dev Team

common/internal/byte_string.cc

@@ -307,15 +307,15 @@ absl::optional<size_t> ByteString::Find(absl::string_view needle,
       [&needle, pos](absl::string_view lhs) -> absl::optional<size_t> {
         absl::string_view::size_type i = lhs.find(needle, pos);
         if (i == absl::string_view::npos) {
-          return absl::nullopt;
+          return std::nullopt;
         }
         return i;
       },
       [&needle, pos](const absl::Cord& lhs) -> absl::optional<size_t> {
         absl::Cord cord = lhs.Subcord(pos, lhs.size() - pos);
         absl::Cord::CharIterator it = cord.Find(needle);
         if (it == cord.char_end()) {
-          return absl::nullopt;
+          return std::nullopt;
         }
         return pos +
                static_cast<size_t>(absl::Cord::Distance(cord.char_begin(), it));
@@ -331,14 +331,14 @@ absl::optional<size_t> ByteString::Find(const absl::Cord& needle,
         if (auto flat_needle = needle.TryFlat(); flat_needle) {
           absl::string_view::size_type i = lhs.find(*flat_needle, pos);
           if (i == absl::string_view::npos) {
-            return absl::nullopt;
+            return std::nullopt;
           }
           return i;
         }
         // Needle is fragmented, we have to do a linear scan.
         const size_t needle_size = needle.size();
         if (pos + needle_size > lhs.size()) {
-          return absl::nullopt;
+          return std::nullopt;
         }
         if (ABSL_PREDICT_FALSE(needle_size == 0)) {
           return pos;
@@ -354,7 +354,7 @@ absl::optional<size_t> ByteString::Find(const absl::Cord& needle,
           size_t found_pos = lhs.find(first_chunk, current_pos);
           if (found_pos == absl::string_view::npos ||
               found_pos > lhs.size() - needle_size) {
-            return absl::nullopt;
+            return std::nullopt;
           }
           if (lhs.substr(found_pos + first_chunk.size(),
                          rest_of_needle.size()) == rest_of_needle) {
@@ -367,7 +367,7 @@ absl::optional<size_t> ByteString::Find(const absl::Cord& needle,
         absl::Cord cord = lhs.Subcord(pos, lhs.size() - pos);
         absl::Cord::CharIterator it = cord.Find(needle);
         if (it == cord.char_end()) {
-          return absl::nullopt;
+          return std::nullopt;
         }
         return pos +
                static_cast<size_t>(absl::Cord::Distance(cord.char_begin(), it));

common/internal/byte_string_test.cc

@@ -766,7 +766,7 @@ TEST_P(ByteStringTest, TryFlatLarge) {
   ByteString byte_string =
       ByteString(GetAllocator(), GetMediumOrLargeFragmentedCord());
   EXPECT_EQ(GetKind(byte_string), ByteStringKind::kLarge);
-  EXPECT_THAT(byte_string.TryFlat(), Eq(absl::nullopt));
+  EXPECT_THAT(byte_string.TryFlat(), Eq(std::nullopt));
   EXPECT_EQ(GetKind(byte_string), ByteStringKind::kLarge);
 }
 
@@ -806,10 +806,10 @@ TEST_P(ByteStringTest, Find) {
   EXPECT_THAT(
       byte_string.Find("small string optimization!"),
       Optional(GetMediumStringView().find("small string optimization!")));
-  EXPECT_THAT(byte_string.Find("not found"), Eq(absl::nullopt));
+  EXPECT_THAT(byte_string.Find("not found"), Eq(std::nullopt));
   EXPECT_THAT(byte_string.Find(""), Optional(0));
   EXPECT_THAT(byte_string.Find("", 3), Optional(3));
-  EXPECT_THAT(byte_string.Find("A string", 1), Eq(absl::nullopt));
+  EXPECT_THAT(byte_string.Find("A string", 1), Eq(std::nullopt));
 
   // Find cord
   EXPECT_THAT(byte_string.Find(absl::Cord("A string")), Optional(0));
@@ -820,33 +820,33 @@ TEST_P(ByteStringTest, Find) {
       byte_string.Find(absl::MakeFragmentedCord(
           {"A string", " that is too large for the small string optimization!",
            " extra"})),
-      Eq(absl::nullopt));
+      Eq(std::nullopt));
   EXPECT_THAT(byte_string.Find(GetMediumOrLargeFragmentedCord()), Optional(0));
-  EXPECT_THAT(byte_string.Find(absl::Cord("not found")), Eq(absl::nullopt));
+  EXPECT_THAT(byte_string.Find(absl::Cord("not found")), Eq(std::nullopt));
   EXPECT_THAT(byte_string.Find(absl::Cord("")), Optional(0));
   EXPECT_THAT(byte_string.Find(absl::Cord(""), 3), Optional(3));
 }
 
 TEST_P(ByteStringTest, FindEdgeCases) {
   ByteString empty_byte_string(GetAllocator(), "");
-  EXPECT_THAT(empty_byte_string.Find("a"), Eq(absl::nullopt));
+  EXPECT_THAT(empty_byte_string.Find("a"), Eq(std::nullopt));
   EXPECT_THAT(empty_byte_string.Find(""), Optional(0));
   ByteString cord_byte_string =
       ByteString(GetAllocator(), GetMediumOrLargeCord());
-  EXPECT_THAT(cord_byte_string.Find("not found"), Eq(absl::nullopt));
+  EXPECT_THAT(cord_byte_string.Find("not found"), Eq(std::nullopt));
   ByteString byte_string = ByteString(GetAllocator(), GetMediumStringView());
 
   // Needle longer than haystack.
   EXPECT_THAT(byte_string.Find(std::string(byte_string.size() + 1, 'a')),
-              Eq(absl::nullopt));
+              Eq(std::nullopt));
 
   // Needle at the end.
   absl::string_view suffix = "optimization!";
   EXPECT_THAT(byte_string.Find(suffix),
               Optional(byte_string.size() - suffix.size()));
 
   // pos at the end.
-  EXPECT_THAT(byte_string.Find("a", byte_string.size()), Eq(absl::nullopt));
+  EXPECT_THAT(byte_string.Find("a", byte_string.size()), Eq(std::nullopt));
   EXPECT_THAT(byte_string.Find("", byte_string.size()),
               Optional(byte_string.size()));
 
@@ -877,7 +877,7 @@ TEST_P(ByteStringTest, FindEdgeCases) {
   // enough space for the rest.
   ByteString short_haystack(GetAllocator(), "abcdefg");
   absl::Cord needle_too_long = absl::MakeFragmentedCord({"ef", "gh"});
-  EXPECT_THAT(short_haystack.Find(needle_too_long), Eq(absl::nullopt));
+  EXPECT_THAT(short_haystack.Find(needle_too_long), Eq(std::nullopt));
 
   // Search with a fragmented empty cord.
   absl::Cord fragmented_empty_cord = absl::MakeFragmentedCord({"", ""});