tagged types

Signed-off-by: Dmitriy Khaustov aka xDimon <[email protected]>

Author: xDimon

include/scale/detail/collections.hpp

@@ -35,9 +35,8 @@ namespace scale {
    * @param encoder The encoder instance to write to.
    */
   void encode(DynamicCollection auto &&collection, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(collection)>
-             and (not std::same_as<std::remove_cvref_t<decltype(collection)>,
-                                   std::vector<bool>>)
+    requires(not std::same_as<std::remove_cvref_t<decltype(collection)>,
+                              std::vector<bool>>)
   {
     encode(as_compact(collection.size()), encoder);
     for (auto &&item : std::forward<decltype(collection)>(collection)) {
@@ -51,8 +50,7 @@ namespace scale {
    * @param encoder The encoder instance to write to.
    */
   void encode(StaticCollection auto &&collection, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(collection)>
-             and (not DecomposableArray<decltype(collection)>)
+    requires(not DecomposableArray<decltype(collection)>)
   {
     for (auto &&item : std::forward<decltype(collection)>(collection)) {
       encode(item, encoder);
@@ -64,9 +62,7 @@ namespace scale {
    * @param view The string view to encode.
    * @param encoder The encoder instance to write to.
    */
-  void encode(const std::string_view view, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(view)>
-  {
+  void encode(const std::string_view view, ScaleEncoder auto &encoder) {
     encode(as_compact(view.size()), encoder);
     encoder.write(
         {reinterpret_cast<const uint8_t *>(view.data()), view.size()});
@@ -79,9 +75,7 @@ namespace scale {
    */
   template <typename T>
     requires std::same_as<std::remove_cvref_t<T>, std::vector<bool>>
-  void encode(T &&vector, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(vector)>
-  {
+  void encode(T &&vector, ScaleEncoder auto &encoder) {
     encode(as_compact(vector.size()), encoder);
     for (const bool item : vector) {
       encoder.put(static_cast<uint8_t>(item ? 1 : 0));
@@ -100,8 +94,7 @@ namespace scale {
    * @param decoder The decoder instance to read from.
    */
   void decode(StaticCollection auto &collection, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(collection)>
-             and (not Decomposable<decltype(collection)>)
+    requires(not Decomposable<decltype(collection)>)
   {
     for (auto &item : collection) {
       decode(item, decoder);
@@ -114,9 +107,7 @@ namespace scale {
    * @param decoder The decoder instance to read from.
    */
   void decode(ExtensibleBackCollection auto &collection,
-              ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(collection)>
-  {
+              ScaleDecoder auto &decoder) {
     using size_type = typename std::decay_t<decltype(collection)>::size_type;
 
     size_t item_count;
@@ -143,9 +134,8 @@ namespace scale {
    * @param collection The collection to decode.
    * @param decoder The decoder instance to read from.
    */
-  void decode(ResizeableCollection auto &collection, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(collection)>
-  {
+  void decode(ResizeableCollection auto &collection,
+              ScaleDecoder auto &decoder) {
     size_t item_count;
     decode(as_compact(item_count), decoder);
     if (item_count > collection.max_size()) {
@@ -169,9 +159,7 @@ namespace scale {
    * but each element can be emplaced while decoding
    */
   void decode(RandomExtensibleCollection auto &collection,
-              ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(collection)>
-  {
+              ScaleDecoder auto &decoder) {
     using size_type = typename std::decay_t<decltype(collection)>::size_type;
     using value_type = typename std::decay_t<decltype(collection)>::value_type;
 

include/scale/detail/decomposable.hpp

@@ -78,9 +78,7 @@ namespace scale {
    * @tparam decomposable The decomposable type to encode.
    * @param encoder The encoder instance to write to.
    */
-  void encode(Decomposable auto &&decomposable, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(decomposable)>
-  {
+  void encode(Decomposable auto &&decomposable, ScaleEncoder auto &encoder) {
     decompose_and_apply(std::forward<decltype(decomposable)>(decomposable),
                         [&](auto &...args) { (encode(args, encoder), ...); });
   }
@@ -90,9 +88,7 @@ namespace scale {
    * @tparam decomposable The decomposable type to decode.
    * @param decoder The decoder instance to read from.
    */
-  void decode(Decomposable auto &decomposable, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(decomposable)>
-  {
+  void decode(Decomposable auto &decomposable, ScaleDecoder auto &decoder) {
     return decompose_and_apply(decomposable, [&](auto &...args) {
       (decode(const_cast<std::remove_cvref_t<decltype(args)> &>(args), decoder),
        ...);

include/scale/detail/enum.hpp

@@ -123,9 +123,7 @@ namespace scale {
    * @param enumeration The enumeration value to encode.
    * @param encoder SCALE encoder.
    */
-  void encode(const Enumeration auto &enumeration, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(enumeration)>
-  {
+  void encode(const Enumeration auto &enumeration, ScaleEncoder auto &encoder) {
     using T =
         std::underlying_type_t<std::remove_cvref_t<decltype(enumeration)>>;
     encode(static_cast<T>(enumeration), encoder);
@@ -136,9 +134,7 @@ namespace scale {
    * @param v The enumeration value to decode into.
    * @param decoder SCALE decoder.
    */
-  void decode(Enumeration auto &v, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(v)>
-  {
+  void decode(Enumeration auto &v, ScaleDecoder auto &decoder) {
     using E = std::decay_t<decltype(v)>;
     std::underlying_type_t<E> value;
     decoder >> value;

include/scale/detail/fixed_width_integer.hpp

@@ -102,9 +102,7 @@ namespace scale {
    * @param boolean Boolean value to encode.
    * @param encoder SCALE encoder.
    */
-  void encode(bool boolean, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(boolean)>
-  {
+  void encode(bool boolean, ScaleEncoder auto &encoder) {
     encoder.put(boolean ? 1u : 0u);
   }
 
@@ -131,9 +129,7 @@ namespace scale {
    * @param integer Integer value to encode.
    * @param encoder SCALE encoder.
    */
-  void encode(const SmallInteger auto &integer, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(integer)>
-  {
+  void encode(const SmallInteger auto &integer, ScaleEncoder auto &encoder) {
     using Integer = std::remove_cvref_t<decltype(integer)>;
     if constexpr (sizeof(Integer) == 1u) {
       return encoder.put(static_cast<uint8_t>(integer));
@@ -151,9 +147,7 @@ namespace scale {
    * @param integer Big integer to encode.
    * @param encoder SCALE encoder.
    */
-  void encode(BigInteger auto &&integer, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(integer)>
-  {
+  void encode(BigInteger auto &&integer, ScaleEncoder auto &encoder) {
     constexpr auto size =
         (std::numeric_limits<std::decay_t<decltype(integer)>>::digits + 1) / 8;
     // NOLINTNEXTLINE(*-pro-type-member-init)

include/scale/detail/optional.hpp

@@ -113,9 +113,7 @@ namespace scale {
    * @param opt_bool The `optional<bool>` to encode.
    * @param encoder The SCALE encoder.
    */
-  void encode(OptionalBool auto &&opt_bool, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(opt_bool)>
-  {
+  void encode(OptionalBool auto &&opt_bool, ScaleEncoder auto &encoder) {
     if (opt_bool.has_value()) {
       encoder.put(static_cast<uint8_t>(opt_bool.value() ? 1  // True
                                                         : 2  // False
@@ -131,9 +129,7 @@ namespace scale {
    * @param optional The optional value to encode.
    * @param encoder The SCALE encoder.
    */
-  void encode(Optional auto &&optional, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(optional)>
-  {
+  void encode(Optional auto &&optional, ScaleEncoder auto &encoder) {
     if (not optional.has_value()) {
       encoder.put(0);
     } else {
@@ -152,9 +148,7 @@ namespace scale {
    * @param opt_bool The `optional<bool>` to decode.
    * @param decoder The SCALE decoder.
    */
-  void decode(OptionalBool auto &&opt_bool, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(opt_bool)>
-  {
+  void decode(OptionalBool auto &&opt_bool, ScaleDecoder auto &decoder) {
     auto byte = decoder.take();
     switch (byte) {
       case 0:
@@ -177,9 +171,7 @@ namespace scale {
    * @param optional The optional value to decode.
    * @param decoder The SCALE decoder.
    */
-  void decode(Optional auto &&optional, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(optional)>
-  {
+  void decode(Optional auto &&optional, ScaleDecoder auto &decoder) {
     auto byte = decoder.take();
     switch (byte) {
       case 0:

include/scale/detail/smart_pointers.hpp

@@ -46,9 +46,7 @@ namespace scale {
    * @throws EncodeError::DEREF_NULLPOINTER if the pointer is null.
    */
   template <typename T>
-  void encode(const std::shared_ptr<T> &sptr, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(sptr)>
-  {
+  void encode(const std::shared_ptr<T> &sptr, ScaleEncoder auto &encoder) {
     if (sptr) {
       return encode(*sptr, encoder);
     }
@@ -63,9 +61,7 @@ namespace scale {
    * @throws EncodeError::DEREF_NULLPOINTER if the pointer is null.
    */
   template <typename T>
-  void encode(const std::unique_ptr<T> &uptr, ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(uptr)>
-  {
+  void encode(const std::unique_ptr<T> &uptr, ScaleEncoder auto &encoder) {
     if (uptr) {
       return encode(*uptr, encoder);
     }
@@ -80,9 +76,7 @@ namespace scale {
    */
   template <typename T>
   void encode(const std::reference_wrapper<T> &reference,
-              ScaleEncoder auto &encoder)
-    requires NoTagged<decltype(reference)>
-  {
+              ScaleEncoder auto &encoder) {
     encode(reference.get(), encoder);
   }
 
@@ -120,9 +114,8 @@ namespace scale {
    * @param decoder SCALE decoder.
    */
   template <typename T>
-  void decode(std::reference_wrapper<T> &reference, ScaleDecoder auto &decoder)
-    requires NoTagged<decltype(reference)>
-  {
+  void decode(std::reference_wrapper<T> &reference,
+              ScaleDecoder auto &decoder) {
     decode(reference.get(), decoder);
   }
 

include/scale/scale.hpp

@@ -4,6 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * @brief Combines all headers to use existing or build custom SCALE
+ * serialization and deserialization mechanisms
+ */
+
 #pragma once
 
 #include <qtils/outcome.hpp>
@@ -24,12 +29,29 @@
 #include <scale/detail/smart_pointers.hpp>
 #include <scale/detail/variant.hpp>
 
+/**
+ * @brief Provides implementations for SCALE encoding and decoding.
+ *
+ * This file defines the memory-based SCALE serialization and deserialization
+ * mechanisms using the Outcome result type to handle errors gracefully.
+ */
+
 namespace scale::impl {
 
-  // Well done implementation using outcome::result and data in memory
+  /**
+   * @namespace memory
+   * @brief Memory-based implementation of SCALE encoding and decoding.
+   */
   namespace memory {
     using Encoder = Encoder<backend::ToBytes>;
 
+    /**
+     * @brief Encodes a value using SCALE encoding.
+     *
+     * @tparam T The type of the value to encode.
+     * @param value The value to encode.
+     * @return A result containing the encoded byte vector or an error.
+     */
     template <typename T>
     outcome::result<std::vector<uint8_t>> encode(T &&value) {
       Encoder encoder;
@@ -43,6 +65,13 @@ namespace scale::impl {
 
     using Decoder = Decoder<backend::FromBytes>;
 
+    /**
+     * @brief Decodes a value using SCALE decoding.
+     *
+     * @tparam T The type of the value to decode.
+     * @param bytes The byte span containing encoded data.
+     * @return A result containing the decoded value or an error.
+     */
     template <typename T>
     outcome::result<T> decode(ConstSpanOfBytes bytes) {
       Decoder decoder{bytes};

include/scale/types.hpp

@@ -21,14 +21,8 @@
 #include <type_traits>
 #include <vector>
 
-#include <qtils/tagged.hpp>
-
 namespace scale {
 
-  /// @brief Concept that ensures a type is not tagged.
-  template <typename T>
-  concept NoTagged = not qtils::is_tagged_v<T>;
-
   // Encoding components
 
   /**