Merge pull request #2420 from nghttp2/nghttpx-ranges-part4

Nghttpx ranges part4

src/buffer_test.cc

@@ -56,13 +56,13 @@ void test_buffer_write(void) {
 
   assert_size(3, ==, b.rleft());
   assert_size(13, ==, b.wleft());
-  assert_ptr_equal(b.pos, std::begin(b.buf));
+  assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
 
   b.drain(3);
 
   assert_size(0, ==, b.rleft());
   assert_size(13, ==, b.wleft());
-  assert_ptrdiff(3, ==, b.pos - std::begin(b.buf));
+  assert_ptrdiff(3, ==, b.pos - std::ranges::begin(b.buf));
 
   auto n = b.write("0123456789ABCDEF", 16);
 
@@ -70,20 +70,20 @@ void test_buffer_write(void) {
 
   assert_size(13, ==, b.rleft());
   assert_size(0, ==, b.wleft());
-  assert_ptrdiff(3, ==, b.pos - std::begin(b.buf));
+  assert_ptrdiff(3, ==, b.pos - std::ranges::begin(b.buf));
   assert_memory_equal(13, b.pos, "0123456789ABC");
 
   b.reset();
 
   assert_size(0, ==, b.rleft());
   assert_size(16, ==, b.wleft());
-  assert_ptr_equal(b.pos, std::begin(b.buf));
+  assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
 
   b.write(5);
 
   assert_size(5, ==, b.rleft());
   assert_size(11, ==, b.wleft());
-  assert_ptr_equal(b.pos, std::begin(b.buf));
+  assert_ptr_equal(b.pos, std::ranges::begin(b.buf));
 }
 
 } // namespace nghttp2

src/shrpx_config.cc

@@ -755,7 +755,7 @@ std::vector<LogFragment> parse_log_format(BlockAllocator &balloc,
       var_name = StringRef{var_name_start, p};
     }
 
-    auto value = std::begin(var_name);
+    auto value = std::ranges::begin(var_name);
 
     auto type = log_var_lookup_token(var_name);
 
@@ -1250,10 +1250,10 @@ int parse_mapping(Config *config, DownstreamAddrConfig &addr,
       auto path = http2::normalize_path_colon(
         downstreamconf.balloc, StringRef{slash, std::ranges::end(raw_pattern)},
         StringRef{});
-      auto iov =
+      auto iov = make_byte_ref(
-        make_byte_ref(downstreamconf.balloc,
+        downstreamconf.balloc,
-                      std::ranges::distance(std::begin(raw_pattern), slash) +
+        std::ranges::distance(std::ranges::begin(raw_pattern), slash) +
-                        path.size() + 1);
+          path.size() + 1);
       auto p = util::tolower(std::ranges::begin(raw_pattern), slash,
                              std::ranges::begin(iov));
       p = std::ranges::copy(path, p).out;

src/shrpx_config_test.cc

@@ -196,25 +196,19 @@ void test_shrpx_config_read_tls_ticket_key_file(void) {
   assert_not_null(ticket_keys.get());
   assert_size(2, ==, ticket_keys->keys.size());
   auto key = &ticket_keys->keys[0];
-  assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
+  assert_true(std::ranges::equal(key->data.name, "0..............1"sv));
-                         "0..............1"));
+  assert_true(std::ranges::equal(std::span{key->data.enc_key}.first(16),
-  assert_true(std::equal(std::begin(key->data.enc_key),
+                                 "2..............3"sv));
-                         std::begin(key->data.enc_key) + 16,
+  assert_true(std::ranges::equal(std::span{key->data.hmac_key}.first(16),
-                         "2..............3"));
+                                 "4..............5"sv));
-  assert_true(std::equal(std::begin(key->data.hmac_key),
-                         std::begin(key->data.hmac_key) + 16,
-                         "4..............5"));
   assert_size(16, ==, key->hmac_keylen);
 
   key = &ticket_keys->keys[1];
-  assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
+  assert_true(std::ranges::equal(key->data.name, "6..............7"sv));
-                         "6..............7"));
+  assert_true(std::ranges::equal(std::span{key->data.enc_key}.first(16),
-  assert_true(std::equal(std::begin(key->data.enc_key),
+                                 "8..............9"sv));
-                         std::begin(key->data.enc_key) + 16,
+  assert_true(std::ranges::equal(std::span{key->data.hmac_key}.first(16),
-                         "8..............9"));
+                                 "a..............b"sv));
-  assert_true(std::equal(std::begin(key->data.hmac_key),
-                         std::begin(key->data.hmac_key) + 16,
-                         "a..............b"));
   assert_size(16, ==, key->hmac_keylen);
 }
 
@@ -245,24 +239,18 @@ void test_shrpx_config_read_tls_ticket_key_file_aes_256(void) {
   assert_not_null(ticket_keys.get());
   assert_size(2, ==, ticket_keys->keys.size());
   auto key = &ticket_keys->keys[0];
-  assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
+  assert_true(std::ranges::equal(key->data.name, "0..............1"sv));
-                         "0..............1"));
+  assert_true(std::ranges::equal(key->data.enc_key,
-  assert_true(std::equal(std::begin(key->data.enc_key),
+                                 "2..............................3"sv));
-                         std::end(key->data.enc_key),
+  assert_true(std::ranges::equal(key->data.hmac_key,
-                         "2..............................3"));
+                                 "4..............................5"sv));
-  assert_true(std::equal(std::begin(key->data.hmac_key),
-                         std::end(key->data.hmac_key),
-                         "4..............................5"));
 
   key = &ticket_keys->keys[1];
-  assert_true(std::equal(std::begin(key->data.name), std::end(key->data.name),
+  assert_true(std::ranges::equal(key->data.name, "6..............7"sv));
-                         "6..............7"));
+  assert_true(std::ranges::equal(key->data.enc_key,
-  assert_true(std::equal(std::begin(key->data.enc_key),
+                                 "8..............................9"sv));
-                         std::end(key->data.enc_key),
+  assert_true(std::ranges::equal(key->data.hmac_key,
-                         "8..............................9"));
+                                 "a..............................b"sv));
-  assert_true(std::equal(std::begin(key->data.hmac_key),
-                         std::end(key->data.hmac_key),
-                         "a..............................b"));
 }
 
 } // namespace shrpx

src/shrpx_http_test.cc

@@ -90,15 +90,17 @@ void test_shrpx_http_create_forwarded(void) {
 void test_shrpx_http_create_via_header_value(void) {
   std::array<char, 16> buf;
 
-  auto end = http::create_via_header_value(std::begin(buf), 1, 1);
+  auto end = http::create_via_header_value(std::ranges::begin(buf), 1, 1);
 
-  assert_stdstring_equal("1.1 nghttpx", (std::string{std::begin(buf), end}));
+  assert_stdstring_equal("1.1 nghttpx",
+                         (std::string{std::ranges::begin(buf), end}));
 
-  std::fill(std::begin(buf), std::end(buf), '\0');
+  std::ranges::fill(buf, '\0');
 
-  end = http::create_via_header_value(std::begin(buf), 2, 0);
+  end = http::create_via_header_value(std::ranges::begin(buf), 2, 0);
 
-  assert_stdstring_equal("2 nghttpx", (std::string{std::begin(buf), end}));
+  assert_stdstring_equal("2 nghttpx",
+                         (std::string{std::ranges::begin(buf), end}));
 }
 
 void test_shrpx_http_create_affinity_cookie(void) {

src/shrpx_worker.h

@@ -278,7 +278,7 @@ struct QUICPacket {
       remote_addr{remote_addr},
       local_addr{local_addr},
       pi{pi},
-      data{std::begin(data), std::end(data)} {}
+      data{std::ranges::begin(data), std::ranges::end(data)} {}
   QUICPacket() : upstream_addr_index{}, remote_addr{}, local_addr{}, pi{} {}
   size_t upstream_addr_index;
   Address remote_addr;

src/siphash.cc

@@ -95,7 +95,7 @@ uint64_t siphash24(std::span<const uint64_t, 2> key,
   }
 
   std::array<uint8_t, sizeof(uint64_t)> last_block{};
-  std::ranges::copy(input, std::begin(last_block));
+  std::ranges::copy(input, std::ranges::begin(last_block));
   last_block.back() = orig_input_len & 0xff;
 
   auto last_block_word = CRYPTO_load_u64_le(last_block);

src/siphash_test.cc

@@ -49,7 +49,7 @@ const MunitSuite siphash_suite{
 
 void test_siphash(void) {
   std::array<uint8_t, 16> key_bytes;
-  std::iota(std::begin(key_bytes), std::end(key_bytes), 0);
+  std::iota(std::ranges::begin(key_bytes), std::ranges::end(key_bytes), 0);
 
   std::array<uint64_t, 2> key;
   memcpy(key.data(), key_bytes.data(), key_bytes.size());
@@ -60,7 +60,7 @@ void test_siphash(void) {
   }
 
   std::array<uint8_t, 15> input;
-  std::iota(std::begin(input), std::end(input), 0);
+  std::iota(std::ranges::begin(input), std::ranges::end(input), 0);
 
   assert_uint64(0xa129ca6149be45e5ull, ==, siphash24(key, input));
 }

src/util_test.cc

@@ -222,8 +222,8 @@ void test_util_percent_encode_token(void) {
 void test_util_percent_decode(void) {
   {
     std::string s = "%66%6F%6f%62%61%72";
-    assert_stdstring_equal("foobar",
+    assert_stdstring_equal("foobar", util::percent_decode(std::ranges::begin(s),
-                           util::percent_decode(std::begin(s), std::end(s)));
+                                                          std::ranges::end(s)));
   }
   {
     std::string s = "%66%6";
@@ -231,8 +231,8 @@ void test_util_percent_decode(void) {
   }
   {
     std::string s = "%66%";
-    assert_stdstring_equal("f%",
+    assert_stdstring_equal(
-                           util::percent_decode(std::begin(s), std::end(s)));
+      "f%", util::percent_decode(std::ranges::begin(s), std::ranges::end(s)));
   }
   BlockAllocator balloc(1024, 1024);
 
@@ -828,9 +828,10 @@ void test_util_random_alpha_digit(void) {
   std::mt19937 gen(rd());
   std::array<uint8_t, 19> data;
 
-  auto p = util::random_alpha_digit(std::begin(data), std::end(data), gen);
+  auto p = util::random_alpha_digit(std::ranges::begin(data),
+                                    std::ranges::end(data), gen);
 
-  assert_true(std::end(data) == p);
+  assert_true(std::ranges::end(data) == p);
 
   for (auto b : data) {
     assert_true(('A' <= b && b <= 'Z') || ('a' <= b && b <= 'z') ||