tagged types

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

Author: xDimon

include/scale/detail/collections.hpp

@@ -17,6 +17,7 @@
 
 #include <scale/detail/collections_type_traits.hpp>
 #include <scale/detail/decomposable_type_traits.hpp>
+#include <scale/detail/tagged.hpp>
 
 namespace scale {
 

include/scale/detail/tagged.hpp

@@ -0,0 +1,61 @@
+ /**
+  * Copyright Quadrivium LLC
+  * All Rights Reserved
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+ /**
+  * @brief Provides encoding and decoding utilities for tagged types in SCALE
+  * serialization.
+  *
+  * This file defines functions for encoding and decoding tagged types,
+  * ensuring proper serialization and deserialization while preserving type
+  * information.
+  */
+
+ #pragma once
+
+ #include <qtils/tagged.hpp>
+
+ #include <scale/detail/compact_integer.hpp>
+ #include <scale/types.hpp>
+
+ namespace scale {
+
+   namespace detail::tagged {
+     /// @brief Concept that ensures a type is not tagged.
+     template <typename T>
+     concept NoTagged = not qtils::is_tagged_v<T>;
+   }  // namespace detail::tagged
+
+   using detail::tagged::NoTagged;
+
+   /**
+    * @brief Encodes a tagged type using SCALE encoding.
+    *
+    * @tparam T The tagged type to encode.
+    * @param tagged The value to encode.
+    * @param encoder The encoder instance to write to.
+    */
+   template <typename T>
+     requires qtils::is_tagged_v<T>
+              and (not detail::compact_integer::CompactInteger<T>)
+   void encode(const T &tagged, ScaleEncoder auto &encoder) {
+     return encode(untagged(tagged), encoder);
+   }
+
+   /**
+    * @brief Decodes a tagged type using SCALE decoding.
+    *
+    * @tparam T The tagged type to decode.
+    * @param tagged The value to decode into.
+    * @param decoder The decoder instance to read from.
+    */
+   template <typename T>
+     requires qtils::is_tagged_v<T>
+              and (not detail::compact_integer::CompactInteger<T>)
+   void decode(T &tagged, ScaleDecoder auto &decoder) {
+     return decode(untagged(tagged), decoder);
+   }
+
+ }  // namespace scale

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>
@@ -23,13 +28,31 @@
 #include <scale/detail/optional.hpp>
 #include <scale/detail/smart_pointers.hpp>
 #include <scale/detail/variant.hpp>
+#include <scale/detail/tagged.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 +66,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

@@ -25,10 +25,6 @@
 
 namespace scale {
 
-  /// @brief Concept that ensures a type is not tagged.
-  template <typename T>
-  concept NoTagged = not qtils::is_tagged_v<T>;
-
   // Encoding components
 
   /**

test/scale_tagged_test.cpp

@@ -0,0 +1,101 @@
+
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @brief Unit tests for encoding and decoding tagged types using SCALE.
+ *
+ * This file contains tests for encoding and decoding tagged types,
+ * ensuring that serialization and deserialization work as expected.
+ */
+
+#include <gtest/gtest.h>
+
+#include <qtils/test/outcome.hpp>
+#include <qtils/tagged.hpp>
+
+#include <scale/scale.hpp>
+
+using scale::ByteArray;
+using scale::impl::memory::decode;
+using scale::impl::memory::encode;
+
+using TaggedString = qtils::Tagged<std::string, class String>;
+using TaggedInteger = qtils::Tagged<uint32_t, class Integer>;
+
+/**
+ * @brief Tests encoding of a tagged string.
+ *
+ * @given A string and its tagged equivalent.
+ * @when Encoding is applied.
+ * @then The serialized value of the tagged string matches the original string.
+ */
+TEST(Tagged, StringEncode) {
+  std::string string = "hello world";
+  TaggedString tagged = "hello world";
+
+  ASSERT_OUTCOME_SUCCESS(encoded_original, encode(string));
+  ASSERT_OUTCOME_SUCCESS(encoded_tagged, encode(tagged));
+
+  ASSERT_EQ(encoded_tagged, encoded_original);
+}
+
+/**
+ * @brief Tests decoding of a tagged string.
+ *
+ * @given A byte sequence containing an encoded string.
+ * @when Decoding is applied.
+ * @then The decoded value matches the original string.
+ */
+TEST(Tagged, StringDecode) {
+  std::string original = "hello world";
+  ASSERT_OUTCOME_SUCCESS(encoded, encode(original));
+
+  ASSERT_OUTCOME_SUCCESS(decoded, decode<TaggedString>(encoded));
+
+  ASSERT_EQ(untagged(decoded), original);
+}
+
+/**
+ * @brief Tests encoding and decoding of a tagged integer.
+ *
+ * @given A tagged integer.
+ * @when The integer is encoded and then decoded.
+ * @then The decoded value matches the original integer.
+ */
+TEST(Tagged, StringEncodeAndDecode) {
+  TaggedString original = "hello world";
+
+  ASSERT_OUTCOME_SUCCESS(encoded, encode(original));
+  ASSERT_OUTCOME_SUCCESS(decoded, decode<TaggedString>(encoded));
+  ASSERT_EQ(decoded, original);
+}
+
+TEST(Tagged, IntegerEncode) {
+  uint32_t integer = 123456789;
+  TaggedInteger tagged(123456789);
+
+  ASSERT_OUTCOME_SUCCESS(encoded_original, encode(integer));
+  ASSERT_OUTCOME_SUCCESS(encoded_tagged, encode(tagged));
+
+  ASSERT_EQ(encoded_tagged, encoded_original);
+}
+
+/**
+ * @brief Tests decoding of a tagged integer.
+ *
+ * @given A byte sequence containing an encoded integer.
+ * @when Decoding is applied.
+ * @then The decoded value matches the original integer.
+ */
+TEST(Tagged, IntegerDecode) {
+  uint32_t original = 123456789;
+  ASSERT_OUTCOME_SUCCESS(encoded, encode(original));
+
+  ASSERT_OUTCOME_SUCCESS(decoded, decode<TaggedInteger>(encoded));
+
+  ASSERT_EQ(untagged(decoded), original);
+}