fix: review issues

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

Author: xDimon

include/scale/detail/custom_decomposing.hpp

@@ -17,11 +17,11 @@
  * struct Point {
  *   int x, y;
  *
- *   SCALE_CUSTOM_DECOMPOSING(Point, x, y);
+ *   SCALE_CUSTOM_DECOMPOSITION(Point, x, y);
  * };
  * @endcode
  */
-#define SCALE_CUSTOM_DECOMPOSING(Self, ...)                                    \
+#define SCALE_CUSTOM_DECOMPOSITION(Self, ...)                                    \
  private:                                                                      \
   decltype(auto) _custom_decompose_and_apply(auto &&f) {                       \
     return std::forward<decltype(f)>(f)(__VA_ARGS__);                          \

include/scale/detail/fixed_width_integer.hpp

@@ -20,26 +20,47 @@ namespace scale {
 
 namespace scale {
 
+  /**
+   * @brief Concept for big fixed-width integer types.
+   *
+   * This concept checks if the given type is one of the predefined large
+   * integer types.
+   */
   template <typename T>
   concept BigFixedWidthInteger =
       std::is_same_v<std::remove_cvref_t<T>, uint128_t>
       or std::is_same_v<std::remove_cvref_t<T>, uint256_t>
       or std::is_same_v<std::remove_cvref_t<T>, uint512_t>
       or std::is_same_v<std::remove_cvref_t<T>, uint1024_t>;
 
+  /**
+   * @brief Traits for determining the size of fixed-width integer types.
+   *
+   * This primary template handles standard integral types.
+   */
   template <typename T, typename = void>
   struct FixedWidthIntegerTraits;
 
-  // Для целочисленных типов
+  /**
+   * @brief Specialization for built-in integral types.
+   */
   template <std::integral T>
   struct FixedWidthIntegerTraits<T> {
     static constexpr size_t bytes = sizeof(T);
     static constexpr size_t bits = bytes * 8;
   };
 
+  /**
+   * @brief Specialization for Boost multiprecision integer types.
+   *
+   * Computes the number of bytes required to store the value,
+   * excluding any metadata or auxiliary data.
+   */
   template <typename T>
   struct FixedWidthIntegerTraits<T, std::enable_if_t<std::is_class_v<T>>> {
    private:
+    // Compute count significant bytes needed to store value,
+    // except any metadata and auxiliaries
     static constexpr size_t compute_bytes() {
       T temp{};
       return temp.backend().size() * sizeof(temp.backend().limbs()[0]);
@@ -51,12 +72,27 @@ namespace scale {
   };
 
   namespace detail {
+    /**
+     * @brief Converts a value from one type to another using static_cast.
+     * @tparam To Target type.
+     * @tparam From Source type.
+     * @param value Value to convert.
+     * @return Converted value.
+     */
     template <typename To, typename From>
       requires std::is_convertible_v<From, To>
     To convert_to(From value) {
       return static_cast<To>(value);
     }
 
+    /**
+     * @brief Specialized conversion for Boost multiprecision numbers.
+     * @tparam To Target type.
+     * @tparam From Boost multiprecision number type.
+     * @param value Value to convert.
+     * @return Converted value.
+     * @throws std::system_error if conversion results in data loss.
+     */
     template <typename To, typename From>
       requires boost::multiprecision::is_number<From>::value
     To convert_to(const From &value) {
@@ -72,10 +108,10 @@ namespace scale {
   }  // namespace detail
 
   /**
-   * encodeInteger encodes any integer type to little-endian representation
-   * @tparam T integer type
-   * @param value integer value
-   * @param stream output stream
+   * @brief Encodes an integer to little-endian representation.
+   * @tparam T Integer type.
+   * @param value Integer value to encode.
+   * @param stream Output stream where encoded data is written.
    */
   template <typename T>
     requires std::is_integral_v<std::remove_cvref_t<T>>
@@ -84,13 +120,18 @@ namespace scale {
     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
+    buf = value;  // Assign value to endian buffer
     for (size_t i = 0; i < size; ++i) {
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-      stream << buf.data()[i];
+      stream << buf.data()[i];  // Write each byte to the stream
     }
   }
 
+  /**
+   * @brief Encodes large fixed-width integers to little-endian format.
+   * @tparam S Type of the SCALE encoder stream.
+   * @param v Integer value to encode.
+   * @param s Encoder stream.
+   */
   template <typename S>
     requires std::derived_from<std::remove_cvref_t<S>, ScaleEncoderStream>
   void encodeInteger(const BigFixedWidthInteger auto &v, S &s) {
@@ -101,20 +142,31 @@ namespace scale {
     }
   }
 
+  /**
+   * @brief Decodes an integer from little-endian representation.
+   * @tparam T Integer type.
+   * @param value Reference to store the decoded integer.
+   * @param stream Input stream from which data is read.
+   */
   template <typename T>
     requires std::is_integral_v<std::remove_cvref_t<T>>
   void decodeInteger(T &value, ScaleDecoderStream &stream) {
     using I = std::remove_cvref_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
+    buf = value;  // Assign initial value
     for (size_t i = 0; i < size; ++i) {
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-      stream >> buf.data()[i];
+      stream >> buf.data()[i];  // Read each byte from the stream
     }
   }
 
+  /**
+   * @brief Decodes large fixed-width integers from little-endian format.
+   * @tparam S Type of the SCALE decoder stream.
+   * @param v Reference to store the decoded integer.
+   * @param s Decoder stream.
+   */
   template <typename S>
     requires std::derived_from<std::remove_cvref_t<S>, ScaleDecoderStream>
   void decodeInteger(BigFixedWidthInteger auto &v, S &s) {

test/scale_custom_decomposing_test.cpp

@@ -25,7 +25,7 @@ struct CustomDecomposableObject {
 
   bool operator==(const CustomDecomposableObject &other) const = default;
 
-  SCALE_CUSTOM_DECOMPOSING(CustomDecomposableObject, b, c, d);
+  SCALE_CUSTOM_DECOMPOSITION(CustomDecomposableObject, b, c, d);
 };
 
 TEST(CustomDecomposable, encode) {