Work through some C++20 notes.

Author: jtv

include/pqxx/connection.hxx

@@ -1058,8 +1058,6 @@ public:
    */
   void set_verbosity(error_verbosity verbosity) & noexcept;
 
-  // C++20: Use std::callable.
-
   /// Set a notice handler to the connection.
   /** When a notice comes in (a warning or error message), the connection or
    * result object on which it happens will call the notice handler, passing

include/pqxx/doc/binary-data.md

@@ -9,8 +9,8 @@ Generally you'll want to use `BYTEA` for reasonably-sized values, and large
 objects for very large values.
 
 That's the database side.  On the C++ side, in libpqxx, all binary data must be
-either `pqxx::bytes` or `pqxx::bytes_view`; or if you're building in C++20 or
-better, anything that's a block of contiguous `std::byte` in memory.
+either `pqxx::bytes` or `pqxx::bytes_view`, or anything else that's a block of
+contiguous `std::byte` in memory.
 
 So for example, if you want to write a large object, you'd create a
 `pqxx::blob` object.  And you might use that to write data in the form of

include/pqxx/internal/conversions.hxx

@@ -103,9 +103,9 @@ inline char *generic_into_buf(char *begin, char *end, T const &value)
 }
 
 
-// C++20: Guard with concept?
+// TODO: Define type_traits<std::integral T> directly?
 /// String traits for builtin integral types (though not bool).
-template<typename T> struct integral_traits
+template<std::integral T> struct integral_traits
 {
   static constexpr bool converts_to_string{true};
   static constexpr bool converts_from_string{true};

include/pqxx/params.hxx

@@ -56,7 +56,6 @@ public:
     return m_params.size();
   }
 
-  // C++20: noexcept.
   /// Get the number of parameters (signed).
   /** Unlike `size()`, this is not yet `noexcept`.  That's because C++17's
    * `std::vector` does not have a `ssize()` member function.  These member

include/pqxx/prepared_statement.hxx

@@ -39,8 +39,8 @@ namespace pqxx
  * zero.  If you need a zero byte, you're dealing with binary strings, not
  * regular strings.  Represent binary strings on the SQL side as `BYTEA`
  * (or as large objects).  On the C++ side, use types like `pqxx::bytes` or
- * `pqxx::bytes_view` or (in C++20) `std::vector<std::byte>`.  Also, consider
- * large objects on the SQL side and @ref blob on the C++ side.
+ * `pqxx::bytes_view` or `std::vector<std::byte>`.  Also, consider large
+ * objects on the SQL side and @ref blob on the C++ side.
  *
  * @warning Passing the wrong number of parameters to a prepared or
  * parameterised statement will _break the connection._  The usual exception

src/connection.cxx

@@ -639,9 +639,13 @@ int pqxx::connection::get_notifs()
     }
 
     auto const handler{m_notification_handlers.find(N->relname)};
-    // C++20: Use "dot notation" to initialise struct fields.
     if (handler != std::end(m_notification_handlers))
-      (handler->second)(notification{*this, channel, N->extra, N->be_pid});
+      (handler->second)(notification{
+        .conn=*this,
+	.channel=channel,
+	.payload=N->extra,
+	.backend_pid=N->be_pid,
+      });
 
     N.reset();
   }

src/encodings.cxx

@@ -65,8 +65,7 @@ pqxx::internal::encoding_group enc_group(std::string_view encoding_name)
         return pqxx::internal::encoding_group::BIG5;
       [[unlikely]] break;
     case 'E':
-      // C++20: Use string_view::starts_with().
-      if ((sz >= 6u) and (encoding_name.substr(0, 4) == "EUC_"sv))
+      if (encoding_name.starts_with("EUC_"sv))
       {
         auto const subtype{encoding_name.substr(4)};
         static constexpr std::array<mapping, 5> subtypes{
@@ -90,8 +89,7 @@ pqxx::internal::encoding_group enc_group(std::string_view encoding_name)
       [[unlikely]] break;
     case 'I':
       // We know iso-8859-X, where 5 <= X < 9.  They're all monobyte encodings.
-      // C++20: Use string_view::starts_with().
-      if ((sz == 10) and (encoding_name.substr(0, 9) == "ISO_8859_"sv))
+      if (encoding_name.starts_with("ISO_8859_"sv))
       {
         char const subtype{encoding_name[9]};
         if (('5' <= subtype) and (subtype < '9'))
@@ -108,8 +106,7 @@ pqxx::internal::encoding_group enc_group(std::string_view encoding_name)
       [[unlikely]] break;
     case 'L':
       // We know LATIN1 through LATIN10.
-      // C++20: Use string_view::starts_with().
-      if (encoding_name.substr(0, 5) == "LATIN"sv)
+      if (encoding_name.starts_with("LATIN"sv))
       {
         auto const subtype{encoding_name.substr(5)};
         if (subtype.size() == 1)
@@ -140,7 +137,7 @@ pqxx::internal::encoding_group enc_group(std::string_view encoding_name)
       if (encoding_name == "UHC"sv)
         return pqxx::internal::encoding_group::UHC;
       else if (encoding_name == "UTF8"sv)
-        return pqxx::internal::encoding_group::UTF8;
+        [[likely]] return pqxx::internal::encoding_group::UTF8;
       [[unlikely]] break;
     case 'W':
       if (encoding_name.substr(0, 3) == "WIN"sv)

src/sql_cursor.cxx

@@ -66,7 +66,6 @@ find_query_end(std::string_view query, pqxx::internal::encoding_group enc)
   if (enc == pqxx::internal::encoding_group::MONOBYTE)
   {
     // This is an encoding where we can scan backwards from the end.
-    // C++20: Use string_view::ends_with() and sub-view.
     while (end > 0 and useless_trail(query[end - 1])) --end;
   }
   else

src/strconv.cxx

@@ -146,7 +146,7 @@ inline char *wrap_to_chars(char *begin, char *end, T const &value)
 
 namespace pqxx::internal
 {
-template<typename T>
+template<std::integral T>
 // NOLINTNEXTLINE(readability-non-const-parameter)
 zview integral_traits<T>::to_buf(char *begin, char *end, T const &value)
 {
@@ -189,7 +189,7 @@ template zview integral_traits<unsigned long long>::to_buf(
   char *, char *, unsigned long long const &);
 
 
-template<typename T>
+template<std::integral T>
 char *integral_traits<T>::into_buf(char *begin, char *end, T const &value)
 {
   // This is exactly what to_chars is good at.  Trust standard library
@@ -527,7 +527,7 @@ template<typename T> std::string to_string_float(T value)
 
 namespace pqxx::internal
 {
-template<typename T> T integral_traits<T>::from_string(std::string_view text)
+template<std::integral T> T integral_traits<T>::from_string(std::string_view text)
 {
   return from_string_arithmetic<T>(text);
 }

test/unit/test_range.cxx

@@ -543,11 +543,7 @@ void test_range_conversion()
 
 constexpr void test_range_is_constexpr()
 {
-// Test compile-time operations.
-//
-// A few things in the standard library need to be constexpr for this to work,
-// so we only test it in C++20.
-#if __cplusplus >= 202002L
+  // Test compile-time operations.
   using range = pqxx::range<int>;
   using ibound = pqxx::inclusive_bound<int>;
 
@@ -556,7 +552,6 @@ constexpr void test_range_is_constexpr()
   static_assert(oneone == oneone);
   static_assert(oneone != onethree);
   static_assert(onethree.contains(oneone));
-#endif
 }