Feature: support for coding of aggregates

CMakeLists.txt

@@ -34,8 +34,8 @@ endif ()
 if (PACKAGE_MANAGER STREQUAL "hunter")
     include(cmake/HunterGate.cmake)
     HunterGate(
-        URL  https://github.com/qdrvm/hunter/archive/refs/tags/v0.25.3-qdrvm28.tar.gz
-        SHA1 a4f1b0f42464e07790b7f90b783a822d71be6c6d
+        URL  https://github.com/qdrvm/hunter/archive/refs/tags/v0.25.3-qdrvm29.tar.gz
+        SHA1 025920fa980ba81a150deaa534a0248dde25fd54
     )
 endif ()
 

README.md

@@ -114,13 +114,13 @@ try {
 ## Convenience functions
 Convenience functions 
 ```c++
-template<class T> 
+template <typename T> 
 outcome::result<std::vector<uint8_t>> encode(T &&t);
 
-template <class T>
+template <typename T>
 outcome::result<T> decode(const RangeOfBytes auto& span)
 
-template <class T>
+template <typename T>
 outcome::result<T> decode(ScaleDecoderStream &s)  
 ```
 are wrappers over ```<<``` and ```>>``` operators described above.

include/scale/detail/aggregate.hpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <scale/types.hpp>
+
+namespace scale::detail {
+
+  template <typename T, typename F>
+    requires SimpleCodeableAggregate<T>
+  auto &as_decomposed(T &&v, const F &f) {
+    constexpr auto N = field_number_of<T>;
+    // clang-format off
+    if constexpr (N == 0) {
+      return f();
+    } else if constexpr (N == 1) {
+      auto &[v1] = v;
+      return f(v1);
+    } else if constexpr (N == 2) {
+      auto &[v1, v2] = v;
+      return f(v1, v2);
+    } else if constexpr (N == 3) {
+      auto &[v1, v2, v3] = v;
+      return f(v1, v2, v3);
+    } else if constexpr (N == 4) {
+      auto &[v1, v2, v3, v4] = v;
+      return f(v1, v2, v3, v4);
+    } else if constexpr (N == 5) {
+      auto &[v1, v2, v3, v4, v5] = v;
+     return f(v1, v2, v3, v4, v5);
+    } else if constexpr (N == 6) {
+      auto &[v1, v2, v3, v4, v5, v6] = v;
+      return f(v1, v2, v3, v4, v5, v6);
+    } else if constexpr (N == 7) {
+      auto &[v1, v2, v3, v4, v5, v6, v7] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7);
+    } else if constexpr (N == 8) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8);
+    } else if constexpr (N == 9) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    } else if constexpr (N == 10) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    } else if constexpr (N == 11) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    } else if constexpr (N == 12) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    } else if constexpr (N == 13) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    } else if constexpr (N == 14) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14);
+    } else if constexpr (N == 15) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
+    } else if constexpr (N == 16) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16);
+    } else if constexpr (N == 17) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17);
+    } else if constexpr (N == 18) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18);
+    } else if constexpr (N == 19) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
+    } else if constexpr (N == 20) {
+      auto &[v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20] = v;
+      return f(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
+    } else {
+      // We mustn't fall in here
+      static_assert(N <= MAX_FIELD_NUM, "Inconsistent value of MAX_FIELD_NUM");
+      static_assert(N > MAX_FIELD_NUM, "No code for cover aggregate with such big amount of fields");
+    }
+    // clang-format on
+  }
+
+}  // namespace scale::detail

include/scale/detail/compact_integer.hpp

@@ -17,6 +17,11 @@
 #include <scale/outcome/outcome_throw.hpp>
 #include <scale/scale_error.hpp>
 #include <scale/types.hpp>
+#include <scale/unreachable.hpp>
+
+namespace scale {
+  class ScaleDecoderStream;
+}
 
 namespace scale::detail {
 
@@ -45,8 +50,10 @@ namespace scale::detail {
    * @return byte array representation of value as compact-integer
    */
   template <typename T, typename S>
-    requires(std::integral<T> or std::is_same_v<T, CompactInteger>)
-  void encodeCompactInteger(T integer, S &s) {
+    requires(std::unsigned_integral<std::decay_t<T>>
+             or std::is_same_v<std::decay_t<T>, CompactInteger>)
+            and std::is_base_of_v<ScaleEncoderStream, S>
+  void encodeCompactInteger(T integer, S &stream) {
     boost::multiprecision::cpp_int value{integer};
 
     // cannot encode negative numbers
@@ -57,19 +64,19 @@ namespace scale::detail {
 
     if (value < kMinUint16) {
       uint8_t v = (value.convert_to<uint8_t>() << 2u) | 0b00;
-      return encodeInteger(v, s);
+      return encodeInteger(v, stream);
     }
 
-    else if (value < kMinUint32) {
+    if (value < kMinUint32) {
       // only values from [kMinUint16, kMinUint32) can be put here
       uint16_t v = (value.convert_to<uint16_t>() << 2u) | 0b01;
-      return encodeInteger(v, s);
+      return encodeInteger(v, stream);
     }
 
-    else if (value < kMinBigInteger) {
+    if (value < kMinBigInteger) {
       // only values from [kMinUint32, kMinBigInteger) can be put here
       uint32_t v = (value.convert_to<uint32_t>() << 2u) | 0b10;
-      return encodeInteger(v, s);
+      return encodeInteger(v, stream);
     }
 
     // number of bytes required to represent value
@@ -91,20 +98,21 @@ namespace scale::detail {
     // to the result of the previous operations.
     uint8_t header = ((significant_bytes_n - 4) << 2u) | 0b11;
 
-    s << header;
+    stream << header;
 
     for (auto v = value; v != 0; v >>= 8) {
       // push back the least significant byte
-      s << static_cast<uint8_t>(v & 0xff);
+      stream << static_cast<uint8_t>(v & 0xff);
     }
   }
 
   template <typename T, typename S>
     requires std::is_same_v<T, CompactInteger>
+             and std::is_base_of_v<ScaleDecoderStream, S>
   T decodeCompactInteger(S &stream) {
     auto first_byte = stream.nextByte();
 
-    const uint8_t flag = (first_byte)&0b00000011u;
+    const uint8_t flag = (first_byte) & 0b00000011u;
 
     size_t number = 0u;
 
@@ -117,7 +125,7 @@ namespace scale::detail {
       case 0b01u: {
         auto second_byte = stream.nextByte();
 
-        number = (static_cast<size_t>((first_byte)&0b11111100u)
+        number = (static_cast<size_t>((first_byte) & 0b11111100u)
                   + static_cast<size_t>(second_byte) * 256u)
                  >> 2u;
         if ((number >> 6) == 0) {
@@ -186,14 +194,14 @@ namespace scale::detail {
    */
   template <typename T, typename S>
     requires std::unsigned_integral<T>
-  T decodeCompactInteger(S &s) {
-    auto integer = decodeCompactInteger<CompactInteger>(s);
+             and std::is_base_of_v<ScaleDecoderStream, S>
+  T decodeCompactInteger(S &stream) {
+    auto integer = decodeCompactInteger<CompactInteger>(stream);
     if (not integer.is_zero()
         and msb(integer) >= std::numeric_limits<T>::digits) {
       raise(DecodeError::DECODED_VALUE_OVERFLOWS_TARGET);
     }
     return static_cast<T>(integer);
   }
 
-
 }  // namespace scale::detail

include/scale/detail/fixed_width_integer.hpp

@@ -6,37 +6,34 @@
 
 #pragma once
 
-#include <algorithm>
-#include <array>
-#include <cstdint>
-#include <vector>
-
 #include <boost/endian/arithmetic.hpp>
 
-#include <scale/outcome/outcome_throw.hpp>
-#include <scale/scale_error.hpp>
-#include <scale/unreachable.hpp>
+namespace scale {
+  class ScaleEncoderStream;
+}
 
 namespace scale::detail {
+
   /**
    * encodeInteger encodes any integer type to little-endian representation
    * @tparam T integer type
-   * @tparam S output stream type
+   * @tparam S output stream type, derived from ScaleEncoderStream
    * @param value integer value
-   * @return byte array representation of value
+   * @param stream output stream
    */
-  template <class T,
-            class S,
-            typename I = std::decay_t<T>,
-            typename = std::enable_if_t<std::is_integral<I>::value>>
-  void encodeInteger(T value, S &out) {  // no need to take integers by &&
+  template <typename T, typename S>
+    requires std::is_integral_v<std::decay_t<T>>
+             && std::is_base_of_v<ScaleEncoderStream, S>
+  void encodeInteger(T value, S &stream) {
+    using I = std::decay_t<T>;
     constexpr size_t size = sizeof(I);
     constexpr size_t bits = size * 8;
     boost::endian::endian_buffer<boost::endian::order::little, I, bits> buf{};
     buf = value;  // cannot initialize, only assign
     for (size_t i = 0; i < size; ++i) {
       // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-      out << buf.data()[i];
+      stream << buf.data()[i];
     }
   }
+
 }  // namespace scale::detail

include/scale/detail/jam_compact_integer.hpp

@@ -25,7 +25,8 @@ namespace scale::detail {
    * @return byte array representation of value as jam-compact-integer
    */
   template <typename T, typename S>
-    requires(std::unsigned_integral<T> or std::is_same_v<T, CompactInteger>)
+    requires(std::unsigned_integral<std::decay_t<T>>
+             or std::is_same_v<std::decay_t<T>, CompactInteger>)
   void encodeJamCompactInteger(T integer, S &s) {
     size_t value;
 
@@ -100,7 +101,8 @@ namespace scale::detail {
       val_mask >>= 1;
       val_bits &= val_mask;
 
-      if ((len_bits & static_cast<uint8_t>(0x80)) == 0) {  // no more significant bytes
+      if ((len_bits & static_cast<uint8_t>(0x80))
+          == 0) {  // no more significant bytes
         value |= static_cast<size_t>(val_bits) << (8 * i);
         break;
       }

include/scale/encode_append.hpp

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <qtils/outcome.hpp>
+#include <scale/scale_encoder_stream.hpp>
 #include <scale/types.hpp>
 
 namespace scale {
@@ -16,16 +17,15 @@ namespace scale {
    */
   struct EncodeOpaqueValue {
     ConstSpanOfBytes v;
-  };
 
-  template <class Stream,
-            typename = std::enable_if_t<Stream::is_encoder_stream>>
-  Stream &operator<<(Stream &s, const EncodeOpaqueValue &value) {
-    for (auto &&it = value.v.begin(), end = value.v.end(); it != end; ++it) {
-      s << *it;
+    friend ScaleEncoderStream &operator<<(ScaleEncoderStream &s,
+                                          const EncodeOpaqueValue &value) {
+      for (auto &item : value.v) {
+        s << item;
+      }
+      return s;
     }
-    return s;
-  }
+  };
 
   /**
    * Adds an EncodeOpaqueValue to a scale encoded vector of EncodeOpaqueValue's.

include/scale/enum_traits.hpp

@@ -14,6 +14,8 @@
 
 namespace scale {
 
+  class ScaleDecoderStream;
+
   /**
    * Description of an enum type
    * Two specialization choices:
@@ -24,12 +26,11 @@ namespace scale {
    * @tparam E the enum type
    */
   template <typename E>
+    requires std::is_enum_v<E>
   struct [[deprecated(
-      "Check the doc comment to see the specialization options")]] enum_traits
-      final {
-    static_assert(std::is_enum_v<E>);
-
-    // to easily detect an unspecialized enum_traits
+      "Check the doc comment to see the specialization options")]]  //
+  enum_traits final {
+    // Used to easily detect an unspecialized enum_traits
     static constexpr bool is_default = true;
   };
 
@@ -63,19 +64,17 @@ namespace scale {
             typename = decltype(E_traits::valid_values)>
   constexpr bool is_valid_enum_value(std::underlying_type_t<E> value) noexcept {
     const auto &valid_values = E_traits::valid_values;
-    return std::find(std::begin(valid_values),
-                     std::end(valid_values),
-                     static_cast<E>(value))
+    return std::ranges::find(valid_values, static_cast<E>(value))
            != std::end(valid_values);
   }
 
-  template <typename T,
-            typename E = std::decay_t<T>,
-            typename = std::enable_if_t<enum_traits<E>::is_default>>
+  template <typename T>
+    requires enum_traits<std::decay_t<T>>::is_default
   [[deprecated(
       "Please specialize scale::enum_traits for your enum so it can be "
-      "validated during decoding")]] constexpr bool
-  is_valid_enum_value(std::underlying_type_t<E> value) noexcept {
+      "validated during decoding")]]
+  constexpr bool is_valid_enum_value(
+      std::underlying_type_t<std::decay_t<T>> value) noexcept {
     return true;
   }
 
@@ -85,12 +84,11 @@ namespace scale {
    * @param v value of enum type
    * @return reference to stream
    */
-  template <typename T,
-            typename S,
-            typename E = std::decay_t<T>,
-            typename = std::enable_if_t<S::is_decoder_stream>,
-            typename = std::enable_if_t<std::is_enum_v<E>>>
+  template <typename S, typename T>
+    requires std::is_base_of_v<ScaleDecoderStream, S>
+             and std::is_enum_v<std::decay_t<T>>
   S &operator>>(S &s, T &v) {
+    using E = std::decay_t<T>;
     std::underlying_type_t<E> value;
     s >> value;
     if (is_valid_enum_value<E>(value)) {