src: Use std::ranges::begin and std::ranges::end consistently

src/h2load.cc

@@ -2791,7 +2791,7 @@ int main(int argc, char **argv) {
 
   // serialize the APLN tokens
   for (auto &proto : config.alpn_list) {
-    proto.insert(proto.begin(), static_cast<char>(proto.size()));
+    proto.insert(std::ranges::begin(proto), static_cast<char>(proto.size()));
   }
 
   std::vector<std::string> reqlines;

src/http2.cc

@@ -274,15 +274,16 @@ namespace {
 void capitalize_long(DefaultMemchunks *buf, const std::string_view &s) {
   buf->append(util::upcase(s[0]));
 
-  auto it = s.begin() + 1;
+  auto it = std::ranges::begin(s) + 1;
 
-  for (; it != s.end();) {
+  for (; it != std::ranges::end(s);) {
-    auto p = std::ranges::find(it, s.end(), '-');
+    auto p = std::ranges::find(it, std::ranges::end(s), '-');
-    p = std::ranges::find_if(p, s.end(), [](auto c) { return c != '-'; });
+    p = std::ranges::find_if(p, std::ranges::end(s),
+                             [](auto c) { return c != '-'; });
 
     buf->append(it, p);
 
-    if (p == s.end()) {
+    if (p == std::ranges::end(s)) {
       return;
     }
 

src/shrpx_http.cc

@@ -131,17 +131,17 @@ std::string_view create_forwarded(BlockAllocator &balloc, uint32_t params,
 std::string colorize_headers(const std::string_view &hdrs) {
   std::string nhdrs;
   auto p = std::ranges::find(hdrs, '\n');
-  if (p == hdrs.end()) {
+  if (p == std::ranges::end(hdrs)) {
     // Not valid HTTP header
     return std::string{hdrs};
   }
 
-  nhdrs.append(hdrs.begin(), ++p);
+  nhdrs.append(std::ranges::begin(hdrs), ++p);
 
   while (1) {
-    auto np = std::ranges::find(p, hdrs.end(), ':');
+    auto np = std::ranges::find(p, std::ranges::end(hdrs), ':');
-    if (np == hdrs.end()) {
+    if (np == std::ranges::end(hdrs)) {
-      nhdrs.append(p, hdrs.end());
+      nhdrs.append(p, std::ranges::end(hdrs));
       break;
     }
 
@@ -153,7 +153,7 @@ std::string colorize_headers(const std::string_view &hdrs) {
 
     p = np;
 
-    np = std::ranges::find(p, hdrs.end(), '\n');
+    np = std::ranges::find(p, std::ranges::end(hdrs), '\n');
 
     if (redact) {
       nhdrs.append(": <redacted>"sv);
@@ -161,7 +161,7 @@ std::string colorize_headers(const std::string_view &hdrs) {
       nhdrs.append(p, np);
     }
 
-    if (np == hdrs.end()) {
+    if (np == std::ranges::end(hdrs)) {
       return nhdrs;
     }
 

src/shrpx_log.cc

@@ -328,7 +328,7 @@ namespace {
 std::span<char> copy_hex_low(std::span<const uint8_t> src,
                              std::span<char> dest) {
   auto n = std::min(dest.size(), src.size() * 2) / 2;
-  auto d = util::format_hex(src.first(n), dest.begin());
+  auto d = util::format_hex(src.first(n), std::ranges::begin(dest));
 
   if (n < src.size()) {
     return {d, d};
@@ -428,7 +428,7 @@ std::span<char> copy_escape(const std::string_view &src, std::span<char> dest) {
 
     dest[0] = '\\';
     dest[1] = 'x';
-    util::format_hex(c, dest.begin() + 2);
+    util::format_hex(c, std::ranges::begin(dest) + 2);
     dest = dest.subspan(4);
 
     safe_first = p + 1;

src/shrpx_quic.h

@@ -58,7 +58,9 @@ std::span<uint64_t, 2> generate_siphash_key();
 
 namespace std {
 template <> struct hash<ngtcp2_cid> {
-  hash() { std::ranges::copy(shrpx::generate_siphash_key(), key.begin()); }
+  hash() {
+    std::ranges::copy(shrpx::generate_siphash_key(), std::ranges::begin(key));
+  }
 
   std::size_t operator()(const ngtcp2_cid &cid) const noexcept {
     return static_cast<size_t>(siphash24(key, {cid.data, cid.datalen}));

src/shrpx_worker.cc

@@ -287,7 +287,7 @@ void Worker::replace_downstream_config(
     shared_mruby_ctxs;
 #endif // defined(HAVE_MRUBY)
 
-  auto old_addr_group_it = old_addr_groups.begin();
+  auto old_addr_group_it = std::ranges::begin(old_addr_groups);
 
   for (size_t i = 0; i < groups.size(); ++i) {
     auto &src = groups[i];
@@ -296,7 +296,7 @@ void Worker::replace_downstream_config(
     dst = std::make_shared<DownstreamAddrGroup>();
     dst->pattern = ImmutableString{src.pattern};
 
-    for (; old_addr_group_it != old_addr_groups.end() &&
+    for (; old_addr_group_it != std::ranges::end(old_addr_groups) &&
            (*old_addr_group_it)->pattern < dst->pattern;
          ++old_addr_group_it)
       ;
@@ -418,7 +418,7 @@ void Worker::replace_downstream_config(
         assert(num_wgs == 0);
 
         auto copy_cycle =
-          old_addr_group_it != old_addr_groups.end() &&
+          old_addr_group_it != std::ranges::end(old_addr_groups) &&
           (*old_addr_group_it)->pattern == dst->pattern &&
           (*old_addr_group_it)->shared_addr->affinity.type ==
             SessionAffinity::NONE &&

src/shrpx_worker_test.cc

@@ -70,7 +70,9 @@ void test_shrpx_worker_match_downstream_addr_group(void) {
 
   for (size_t i = 0; i < groups.size(); ++i) {
     auto &g = groups[i];
-    router.add_route(std::string_view{g->pattern.begin(), g->pattern.end()}, i);
+    router.add_route(std::string_view{std::ranges::begin(g->pattern),
+                                      std::ranges::end(g->pattern)},
+                     i);
   }
 
   assert_size(0, ==,

src/template_test.cc

@@ -177,15 +177,17 @@ void test_template_as_string_view(void) {
     auto a = std::to_array<uint8_t>({'a', 'l', 'p', 'h', 'a'});
 
     assert_stdsv_equal("alpha"sv, as_string_view(a));
-    assert_stdsv_equal("alpha"sv, as_string_view(a.begin(), a.end()));
+    assert_stdsv_equal(
-    assert_stdsv_equal("alp"sv, as_string_view(a.begin(), 3));
+      "alpha"sv, as_string_view(std::ranges::begin(a), std::ranges::end(a)));
+    assert_stdsv_equal("alp"sv, as_string_view(std::ranges::begin(a), 3));
   }
 
   {
     auto s = ""s;
 
     assert_stdsv_equal(""sv, as_string_view(s));
-    assert_stdsv_equal(""sv, as_string_view(s.begin(), s.end()));
+    assert_stdsv_equal(
+      ""sv, as_string_view(std::ranges::begin(s), std::ranges::end(s)));
   }
 }
 

src/util.cc

@@ -613,7 +613,8 @@ time_t parse_openssl_asn1_time_print(const std::string_view &s) {
 }
 
 void to_token68(std::string &base64str) {
-  for (auto it = base64str.begin(); it != base64str.end(); ++it) {
+  for (auto it = std::ranges::begin(base64str);
+       it != std::ranges::end(base64str); ++it) {
     switch (*it) {
     case '+':
       *it = '-';
@@ -622,7 +623,7 @@ void to_token68(std::string &base64str) {
       *it = '_';
       break;
     case '=':
-      base64str.erase(it, base64str.end());
+      base64str.erase(it, std::ranges::end(base64str));
       return;
     }
   }

src/util_test.cc

@@ -195,25 +195,29 @@ void test_util_percent_encode_token(void) {
   std::array<char, 64> buf;
 
   assert_stdsv_equal(
-    "h2"sv, as_string_view(buf.begin(),
+    "h2"sv, as_string_view(
-                           util::percent_encode_token("h2"sv, buf.begin())));
+              std::ranges::begin(buf),
+              util::percent_encode_token("h2"sv, std::ranges::begin(buf))));
 
   assert_size("h2"sv.size(), ==, util::percent_encode_tokenlen("h2"sv));
 
   assert_stdsv_equal(
-    "h3~"sv, as_string_view(buf.begin(),
+    "h3~"sv, as_string_view(
-                            util::percent_encode_token("h3~"sv, buf.begin())));
+               std::ranges::begin(buf),
+               util::percent_encode_token("h3~"sv, std::ranges::begin(buf))));
 
   assert_size("h3~"sv.size(), ==, util::percent_encode_tokenlen("h3~"sv));
 
   assert_stdsv_equal("100%25"sv,
-                     as_string_view(buf.begin(), util::percent_encode_token(
+                     as_string_view(std::ranges::begin(buf),
-                                                   "100%"sv, buf.begin())));
+                                    util::percent_encode_token(
+                                      "100%"sv, std::ranges::begin(buf))));
   assert_size("100%25"sv.size(), ==, util::percent_encode_tokenlen("100%"sv));
 
   assert_stdsv_equal("http%202"sv,
-                     as_string_view(buf.begin(), util::percent_encode_token(
+                     as_string_view(std::ranges::begin(buf),
-                                                   "http 2"sv, buf.begin())));
+                                    util::percent_encode_token(
+                                      "http 2"sv, std::ranges::begin(buf))));
 
   assert_size("http%202"sv.size(), ==,
               util::percent_encode_tokenlen("http 2"sv));
@@ -260,23 +264,29 @@ void test_util_utox(void) {
   std::array<char, 16> buf;
 
   assert_stdsv_equal(
-    "0"sv, (std::string_view{buf.begin(), util::utox(0, buf.begin())}));
+    "0"sv, (std::string_view{std::ranges::begin(buf),
+                             util::utox(0, std::ranges::begin(buf))}));
   assert_stdsv_equal(
-    "1"sv, (std::string_view{buf.begin(), util::utox(1, buf.begin())}));
+    "1"sv, (std::string_view{std::ranges::begin(buf),
+                             util::utox(1, std::ranges::begin(buf))}));
   assert_stdsv_equal(
-    "F"sv, (std::string_view{buf.begin(), util::utox(15, buf.begin())}));
+    "F"sv, (std::string_view{std::ranges::begin(buf),
+                             util::utox(15, std::ranges::begin(buf))}));
   assert_stdsv_equal(
-    "10"sv, (std::string_view{buf.begin(), util::utox(16, buf.begin())}));
+    "10"sv, (std::string_view{std::ranges::begin(buf),
+                              util::utox(16, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "3B9ACA07"sv,
-    (std::string_view{buf.begin(), util::utox(1000000007, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
-  assert_stdsv_equal(
+                      util::utox(1000000007, std::ranges::begin(buf))}));
-    "B5EA98F3663B14A"sv,
+  assert_stdsv_equal("B5EA98F3663B14A"sv,
-    (std::string_view{buf.begin(),
+                     (std::string_view{std::ranges::begin(buf),
-                      util::utox(819278614785929546, buf.begin())}));
+                                       util::utox(819278614785929546,
+                                                  std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "100000000"sv,
-    (std::string_view{buf.begin(), util::utox(1LL << 32, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::utox(1LL << 32, std::ranges::begin(buf))}));
 }
 
 void test_util_http_date(void) {
@@ -855,28 +865,31 @@ void test_util_format_hex(void) {
   std::array<char, 64> buf;
 
   assert_stdsv_equal(
-    "00"sv,
+    "00"sv, (std::string_view{std::ranges::begin(buf),
-    (std::string_view{
+                              util::format_hex(static_cast<uint8_t>(0u),
-      buf.begin(), util::format_hex(static_cast<uint8_t>(0u), buf.begin())}));
+                                               std::ranges::begin(buf))}));
   assert_stdsv_equal(
-    "ec"sv,
+    "ec"sv, (std::string_view{std::ranges::begin(buf),
-    (std::string_view{buf.begin(), util::format_hex(static_cast<uint8_t>(0xecu),
+                              util::format_hex(static_cast<uint8_t>(0xecu),
-                                                    buf.begin())}));
+                                               std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "00000000"sv,
-    (std::string_view{buf.begin(), util::format_hex(0u, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_hex(0u, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "0000ab01"sv,
-    (std::string_view{buf.begin(), util::format_hex(0xab01u, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_hex(0xab01u, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "deadbeefbaadf00d"sv,
-    (std::string_view{buf.begin(),
+    (std::string_view{
-                      util::format_hex(0xdeadbeefbaadf00du, buf.begin())}));
+      std::ranges::begin(buf),
+      util::format_hex(0xdeadbeefbaadf00du, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "ffffffffffffffff"sv,
-    (std::string_view{
+    (std::string_view{std::ranges::begin(buf),
-      buf.begin(),
+                      util::format_hex(std::numeric_limits<uint64_t>::max(),
-      util::format_hex(std::numeric_limits<uint64_t>::max(), buf.begin())}));
+                                       std::ranges::begin(buf))}));
 }
 
 void test_util_format_upper_hex(void) {
@@ -884,19 +897,24 @@ void test_util_format_upper_hex(void) {
 
   assert_stdsv_equal(
     "00"sv,
-    (std::string_view{buf.begin(), util::format_upper_hex(0, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_upper_hex(0, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "0A"sv,
-    (std::string_view{buf.begin(), util::format_upper_hex(0xa, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_upper_hex(0xa, std::ranges::begin(buf))}));
   assert_stdsv_equal(
-    "7C"sv, (std::string_view{buf.begin(),
+    "7C"sv,
-                              util::format_upper_hex(0x07c, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_upper_hex(0x07c, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "EB"sv,
-    (std::string_view{buf.begin(), util::format_upper_hex(0xeb, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_upper_hex(0xeb, std::ranges::begin(buf))}));
   assert_stdsv_equal(
     "FF"sv,
-    (std::string_view{buf.begin(), util::format_upper_hex(0xff, buf.begin())}));
+    (std::string_view{std::ranges::begin(buf),
+                      util::format_upper_hex(0xff, std::ranges::begin(buf))}));
 }
 
 void test_util_is_hex_string(void) {