From 70ef92367da8ccbc6b4b3c13e2e92ecdd9a47dfe Mon Sep 17 00:00:00 2001
From: Marcin Kowalczyk <qrczak@google.com>
Date: Tue, 5 Nov 2024 14:27:30 +0100
Subject: [PATCH] Support digest conversions also from arrays of integers of
 smaller sizes to integers or arrays of integers of larger sizes.

To prevent infinite recursion, in these cases further conversions using
`DigestConverterImpl` are not considered, only types which can be natively
explicitly converted.

This is useful to express the result of `HighwayHash128Digester` as
`absl::uint128` instead of `std::array<uint64_t, 2>`, or to express the result
of OpenSSL-based digesters as `std::array<uint64_t, size>` instead of
`std::array<char, size * sizeof(uint64_t)>`.

Also, ensure that if a digest is already natively convertible to the target
type, then `DigestConverterImpl` does not consider any other conversion first,
which would be ambiguous given that the native conversion is available too.

PiperOrigin-RevId: 693311655
---
 riegeli/digests/BUILD              |   1 +
 riegeli/digests/digest_converter.h | 109 +++++++++++++++++++++++++----
 2 files changed, 98 insertions(+), 12 deletions(-)

diff --git a/riegeli/digests/BUILD b/riegeli/digests/BUILD
index d938e54c..de07adbb 100644
--- a/riegeli/digests/BUILD
+++ b/riegeli/digests/BUILD
@@ -9,6 +9,7 @@ cc_library(
     name = "digest_converter",
     hdrs = ["digest_converter.h"],
     deps = [
+        "//riegeli/endian:endian_reading",
         "//riegeli/endian:endian_writing",
         "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/numeric:int128",
diff --git a/riegeli/digests/digest_converter.h b/riegeli/digests/digest_converter.h
index 6869da8e..2443e9ba 100644
--- a/riegeli/digests/digest_converter.h
+++ b/riegeli/digests/digest_converter.h
@@ -25,6 +25,7 @@
 
 #include "absl/meta/type_traits.h"
 #include "absl/numeric/int128.h"
+#include "riegeli/endian/endian_reading.h"
 #include "riegeli/endian/endian_writing.h"
 
 namespace riegeli {
@@ -48,6 +49,17 @@ struct HasDigestConverterImpl<
     absl::void_t<decltype(DigestConverterImpl<From, To>::Convert(
         std::declval<From>()))>> : std::true_type {};
 
+// `DigestConverterImpl<From, To>` tries to transform `From` from types with
+// more information to types with less information, or from integers or arrays
+// of integers of larger sizes to arrays of integers of smaller sizes, and then
+// considers further transformations, until reaching a type which can be
+// natively explicitly converted to `To`.
+//
+// To prevent infinite recursion, in conversions from arrays of integers of
+// smaller sizes to integers or arrays of integers of larger sizes, further
+// conversions using `DigestConverterImpl` are not considered, only types which
+// can be natively explicitly converted.
+
 // A digest can be converted if its type can be natively explicitly converted.
 // This includes the case when `To` is the same as `From`.
 template <typename From, typename To>
@@ -63,7 +75,7 @@ struct DigestConverterImpl<
             std::enable_if_t<!std::is_lvalue_reference<DependentFrom>::value,
                              int> = 0>
   static To Convert(From&& digest) {
-    return To(std::move(digest));
+    return To(std::forward<From>(digest));
   }
 };
 
@@ -71,7 +83,9 @@ struct DigestConverterImpl<
 template <size_t size, typename To>
 struct DigestConverterImpl<
     std::array<char, size>, To,
-    std::enable_if_t<HasDigestConverterImpl<std::string, To>::value>> {
+    std::enable_if_t<absl::conjunction<
+        absl::negation<std::is_constructible<To, std::array<char, size>>>,
+        HasDigestConverterImpl<std::string, To>>::value>> {
   static To Convert(const std::array<char, size>& digest) {
     return DigestConverterImpl<std::string, To>::Convert(
         std::string(digest.data(), digest.size()));
@@ -79,13 +93,15 @@ struct DigestConverterImpl<
 };
 
 // `uint32_t`, `uint64_t`, and `absl::uint128` can be converted to
-// `std::array<char, sizeof(T)>`.
+// `std::array<char, sizeof(T)>`, using Big Endian.
 
 template <typename To>
 struct DigestConverterImpl<
     uint32_t, To,
-    std::enable_if_t<HasDigestConverterImpl<std::array<char, sizeof(uint32_t)>,
-                                            To>::value>> {
+    std::enable_if_t<absl::conjunction<
+        absl::negation<std::is_constructible<To, uint32_t>>,
+        HasDigestConverterImpl<std::array<char, sizeof(uint32_t)>,
+                               To>>::value>> {
   static To Convert(uint32_t digest) {
     std::array<char, sizeof(uint32_t)> result;
     riegeli::WriteBigEndian32(digest, result.data());
@@ -97,8 +113,10 @@ struct DigestConverterImpl<
 template <typename To>
 struct DigestConverterImpl<
     uint64_t, To,
-    std::enable_if_t<HasDigestConverterImpl<std::array<char, sizeof(uint64_t)>,
-                                            To>::value>> {
+    std::enable_if_t<absl::conjunction<
+        absl::negation<std::is_constructible<To, uint64_t>>,
+        HasDigestConverterImpl<std::array<char, sizeof(uint64_t)>,
+                               To>>::value>> {
   static To Convert(uint64_t digest) {
     std::array<char, sizeof(uint64_t)> result;
     riegeli::WriteBigEndian64(digest, result.data());
@@ -110,8 +128,10 @@ struct DigestConverterImpl<
 template <typename To>
 struct DigestConverterImpl<
     absl::uint128, To,
-    std::enable_if_t<HasDigestConverterImpl<
-        std::array<char, sizeof(absl::uint128)>, To>::value>> {
+    std::enable_if_t<absl::conjunction<
+        absl::negation<std::is_constructible<To, absl::uint128>>,
+        HasDigestConverterImpl<std::array<char, sizeof(absl::uint128)>,
+                               To>>::value>> {
   static To Convert(absl::uint128 digest) {
     std::array<char, sizeof(absl::uint128)> result;
     riegeli::WriteBigEndian128(digest, result.data());
@@ -120,13 +140,56 @@ struct DigestConverterImpl<
   }
 };
 
+// `std::array<char, sizeof(T)>` can be converted to `uint32_t`, `uint64_t`,
+// and `absl::uint128`, using Big Endian.
+//
+// To prevent infinite recursion, further conversions using
+// `DigestConverterImpl` are not considered, only types which can be natively
+// explicitly converted.
+
+template <typename To>
+struct DigestConverterImpl<std::array<char, sizeof(uint32_t)>, To,
+                           std::enable_if_t<absl::conjunction<
+                               absl::negation<std::is_constructible<
+                                   To, std::array<char, sizeof(uint32_t)>>>,
+                               std::is_constructible<To, uint32_t>>::value>> {
+  static To Convert(std::array<char, sizeof(uint32_t)> digest) {
+    return To(riegeli::ReadBigEndian32(digest.data()));
+  }
+};
+
+template <typename To>
+struct DigestConverterImpl<std::array<char, sizeof(uint64_t)>, To,
+                           std::enable_if_t<absl::conjunction<
+                               absl::negation<std::is_constructible<
+                                   To, std::array<char, sizeof(uint64_t)>>>,
+                               std::is_constructible<To, uint64_t>>::value>> {
+  static To Convert(std::array<char, sizeof(uint64_t)> digest) {
+    return To(riegeli::ReadBigEndian64(digest.data()));
+  }
+};
+
+template <typename To>
+struct DigestConverterImpl<
+    std::array<char, sizeof(absl::uint128)>, To,
+    std::enable_if_t<
+        absl::conjunction<absl::negation<std::is_constructible<
+                              To, std::array<char, sizeof(absl::uint128)>>>,
+                          std::is_constructible<To, absl::uint128>>::value>> {
+  static To Convert(std::array<char, sizeof(absl::uint128)> digest) {
+    return To(riegeli::ReadBigEndian128(digest.data()));
+  }
+};
+
 // `std::array<uint64_t, size>` can be converted to
-// `std::array<char, size * sizeof(uint64_t)>`.
+// `std::array<char, size * sizeof(uint64_t)>`, using Big Endian.
 template <size_t size, typename To>
 struct DigestConverterImpl<
     std::array<uint64_t, size>, To,
-    std::enable_if_t<HasDigestConverterImpl<
-        std::array<char, size * sizeof(uint64_t)>, To>::value>> {
+    std::enable_if_t<absl::conjunction<
+        absl::negation<std::is_constructible<To, std::array<uint64_t, size>>>,
+        HasDigestConverterImpl<std::array<char, size * sizeof(uint64_t)>,
+                               To>>::value>> {
   static To Convert(const std::array<uint64_t, size>& digest) {
     std::array<char, size * sizeof(uint64_t)> result;
     riegeli::WriteBigEndian64s(absl::MakeConstSpan(digest.data(), size),
@@ -136,6 +199,28 @@ struct DigestConverterImpl<
   }
 };
 
+// `std::array<char, size * sizeof(uint64_t)>` can be converted to
+// `std::array<uint64_t, size>`, using Big Endian.
+//
+// To prevent infinite recursion, further conversions using
+// `DigestConverterImpl` are not considered, only types which can be natively
+// explicitly converted.
+template <size_t size, typename To>
+struct DigestConverterImpl<
+    std::array<char, size>, To,
+    std::enable_if_t<absl::conjunction<
+        std::integral_constant<bool, size % sizeof(uint64_t) == 0>,
+        absl::negation<std::is_constructible<To, std::array<char, size>>>,
+        std::is_constructible<
+            To, std::array<uint64_t, size / sizeof(uint64_t)>>>::value>> {
+  static To Convert(const std::array<char, size>& digest) {
+    std::array<uint64_t, size / sizeof(uint64_t)> result;
+    riegeli::ReadBigEndian64s(
+        digest.data(), absl::MakeSpan(result.data(), size / sizeof(uint64_t)));
+    return To(result);
+  }
+};
+
 // `DigestConverter<From, To>` extends `DigestConverterImpl<From, To>` with the
 // case of `To` being a reference.