refactor: assert for abnormal aggregate

Signed-off-by: Dmitriy Khaustov aka xDimon <khaustov.dm@gmail.com>

Author: xDimon

include/scale/detail/decomposable.hpp

@@ -66,6 +66,12 @@ namespace scale {
     template <typename F>
     decltype(auto) decompose_and_apply(DecomposableAggregate auto &&v,
                                        const F &f) {
+      using T = std::remove_cvref_t<decltype(v)>;
+      static_assert(
+          std::is_empty_v<T> or field_number_of<T> > 0,
+          "Unusual decomposition of non empty aggregate; Use macro "
+          "'SCALE_CUSTOM_DECOMPOSITION' to define custom decomposition way");
+
       return decompose_and_apply<field_number_of<decltype(v)>>(
           std::forward<decltype(v)>(v), f);
     }

include/scale/detail/decomposable_type_traits.hpp

@@ -84,16 +84,6 @@ namespace scale::detail::decomposable {
     template <typename T>
     concept DecomposableArray = not custom::CustomDecomposable<T>
                                 and ArrayWithMaxSize<T, MAX_FIELD_NUM>;
-
-    /**
-     * @brief Decomposes an array and applies a given function.
-     */
-    template <typename F>
-    decltype(auto) decompose_and_apply(DecomposableArray auto &&v, const F &f) {
-      return decompose_and_apply<array_size<decltype(v)>>(
-          std::forward<decltype(v)>(v), f);
-    }
-
   }  // namespace array
 
   namespace structurally_bindable {
@@ -139,18 +129,6 @@ namespace scale::detail::decomposable {
         (not custom::CustomDecomposable<T>)
         and (not array::DecomposableArray<T>)
         and StructurallyBindableWithMaxSize<T>;
-
-    /**
-     * @brief Decomposes a structurally bindable type and applies a given
-     * function.
-     */
-    template <typename F>
-    decltype(auto) decompose_and_apply(
-        DecomposableStructurallyBindable auto &&v, const F &f) {
-      return decompose_and_apply<structured_binding_size_v<decltype(v)>>(
-          std::forward<decltype(v)>(v), f);
-    }
-
   }  // namespace structurally_bindable
 
   namespace aggregate {
@@ -199,17 +177,6 @@ namespace scale::detail::decomposable {
         and (not array::DecomposableArray<T>)
         and (not structurally_bindable::DecomposableStructurallyBindable<T>)
         and (not collections::Collection<T>) and AggregateWithMaxSize<T>;
-
-    /**
-     * @brief Decomposes an aggregate and applies a given function.
-     */
-    template <typename F>
-    decltype(auto) decompose_and_apply(DecomposableAggregate auto &&v,
-                                       const F &f) {
-      return decompose_and_apply<field_number_of<decltype(v)>>(
-          std::forward<decltype(v)>(v), f);
-    }
-
   }  // namespace aggregate
 
   using aggregate::DecomposableAggregate;

test/scale_decomposable_test.cpp

@@ -5,8 +5,8 @@
  */
 
 /**
- * @brief Unit tests for verifying the correctness of SCALE encoding and decoding
- *        for various decomposable data structures.
+ * @brief Unit tests for verifying the correctness of SCALE encoding and
+ * decoding for various decomposable data structures.
  *
  * This file contains test cases that check the encoding and decoding of
  * fundamental types, arrays, tuples, and user-defined structures using
@@ -17,6 +17,7 @@
 
 #include <set>
 
+#include <qtils/empty.hpp>
 #include <qtils/test/outcome.hpp>
 #include <scale/bitvec.hpp>
 #include <scale/scale.hpp>
@@ -31,6 +32,17 @@ using scale::impl::memory::encode;
 using Encoder = scale::backend::ToBytes;
 using Decoder = scale::backend::FromBytes;
 
+TEST(Decomposable, Empty) {
+  using Testee = qtils::Empty;
+
+  Testee value{};
+
+  ASSERT_OUTCOME_SUCCESS(encoded, encode(value));
+  ASSERT_OUTCOME_SUCCESS(decode<Testee>(encoded));
+
+  ASSERT_TRUE(encoded.empty());
+}
+
 TEST(Decomposable, C_Style_array) {
   using Testee = const uint16_t[3];