Update ref_app hash sha256

Author: ckormanyos

examples/chapter11_07a/src/app/pi_spigot/pi_spigot.cpp

@@ -49,11 +49,11 @@ namespace local
     return instance;
   }
 
-  auto pi_output_digits10 = static_cast<std::uint32_t>(UINT8_C(0));
+  auto pi_output_digits10 = std::uint32_t { UINT8_C(0) };
 
   using benchmark_port_type = ::mcal::benchmark::benchmark_port_type;
 
-  constexpr auto pi_spigot_input_start_address = static_cast<mcal_sram_uintptr_t>(UINT8_C(0));
+  constexpr auto pi_spigot_input_start_address = mcal_sram_uintptr_t { UINT8_C(0) };
 
   using pi_spigot_input_container_type = mcal::memory::sram::array<std::uint32_t,
                                                                    pi_spigot_type::get_input_static_size(),

ref_app/ref_app.vcxproj

@@ -1477,6 +1477,7 @@
     <ClInclude Include="src\math\checksums\hash\hash_detail.h" />
     <ClInclude Include="src\math\checksums\hash\hash_sha1.h" />
     <ClInclude Include="src\math\checksums\hash\hash_sha256.h" />
+    <ClInclude Include="src\math\checksums\hash\hash_stream_base.h" />
     <ClInclude Include="src\math\constants\constants.h" />
     <ClInclude Include="src\math\constants\constant_functions.h" />
     <ClInclude Include="src\math\constants\pi_spigot_base.h" />

ref_app/ref_app.vcxproj.filters

@@ -3042,6 +3042,9 @@
     <ClInclude Include="src\mcal_memory\mcal_memory_sram_types.h">
       <Filter>src\mcal_memory</Filter>
     </ClInclude>
+    <ClInclude Include="src\math\checksums\hash\hash_stream_base.h">
+      <Filter>src\math\checksums\hash</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="src\util\STL\algorithm">

ref_app/src/app/benchmark/app_benchmark_hash_sha256.cpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-//  Copyright Christopher Kormanyos 2013 - 2023.
+//  Copyright Christopher Kormanyos 2013 - 2026.
 //  Distributed under the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt
 //  or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -14,7 +14,7 @@
 
 namespace
 {
-  using app_benchmark_hash_type = math::checksums::hash::hash_sha256<std::uint_fast16_t>;
+  using app_benchmark_hash_type = math::checksums::hash::hash_sha256;
 
   app_benchmark_hash_type app_benchmark_hash_object;
 
@@ -33,17 +33,19 @@ namespace
 
 auto app::benchmark::run_hash_sha256() -> bool
 {
-  static constexpr std::array<std::uint8_t, static_cast<std::size_t>(UINT8_C(3))> app_benchmark_hash_data =
+  using app_benchmark_msg_array_type = std::array<std::uint8_t, static_cast<std::size_t>(UINT8_C(3))>;
+
+  constexpr app_benchmark_msg_array_type app_benchmark_hash_msg =
   {
     static_cast<std::uint8_t>('a'),
     static_cast<std::uint8_t>('b'),
     static_cast<std::uint8_t>('c')
   };
 
-  app_benchmark_hash_object.hash(app_benchmark_hash_data.data(),
-                                 static_cast<app_benchmark_hash_count_type>(app_benchmark_hash_data.size()));
+  app_benchmark_hash_object.hash(app_benchmark_hash_msg.data(),
+                                 static_cast<app_benchmark_hash_count_type>(std::tuple_size<app_benchmark_msg_array_type>::value));
 
-  auto local_hash_result = app_benchmark_hash_result_type { };
+  app_benchmark_hash_result_type local_hash_result { };
 
   app_benchmark_hash_object.get_result(local_hash_result.data());
 

ref_app/src/math/checksums/hash/hash_base.h

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-//  Copyright Christopher Kormanyos 2013 - 2025.
+//  Copyright Christopher Kormanyos 2013 - 2026.
 //  Distributed under the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt
 //  or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -8,58 +8,62 @@
 #ifndef HASH_BASE_2013_09_05_H
   #define HASH_BASE_2013_09_05_H
 
-  #include <limits>
-
   #include <math/checksums/hash/hash_detail.h>
+  #include <math/checksums/hash/hash_stream_base.h>
+
+  #include <array>
+  #include <cstddef>
+  #include <cstdint>
+  #include <limits>
 
   namespace math { namespace checksums { namespace hash {
 
-  template<typename CountType,
-           const std::uint16_t ResultBitCount,
-           const std::uint16_t MessageBufferSize,
-           const std::uint16_t MessageLengthTotalBitCount>
-  class hash_base
+  template<const std::uint16_t ResultBitCount,
+           const std::uint16_t MessageBlockBufferSize,
+           const std::uint16_t MessageBlockBitCount>
+  class hash_base : public hash_stream_base
   {
-  public:
-    using count_type = CountType;
+  private:
+    using base_class_type = hash_stream_base;
 
+  public:
     using result_type = std::array<std::uint8_t, static_cast<std::size_t>(ResultBitCount / static_cast<std::uint16_t>(UINT8_C(8)))>;
 
     static_assert
     (
-           std::numeric_limits<count_type>::is_specialized
-      &&   std::numeric_limits<count_type>::is_integer
-      && (!std::numeric_limits<count_type>::is_signed)
-      && (std::numeric_limits<count_type>::radix == static_cast<int>(INT8_C(2)))
-      && (std::numeric_limits<count_type>::digits >= static_cast<int>(INT8_C(16)))
-      && (static_cast<int>(std::numeric_limits<count_type>::digits % static_cast<int>(INT8_C(8))) == static_cast<int>(INT8_C(0))),
-      "Error: The count type must be an unsigned integer with radix 2, that is 16 bits or wider, and having a multiple of 8 bits"
+           std::numeric_limits<base_class_type::count_type>::is_specialized
+      &&   std::numeric_limits<base_class_type::count_type>::is_integer
+      && (!std::numeric_limits<base_class_type::count_type>::is_signed)
+      && (std::numeric_limits<base_class_type::count_type>::radix == static_cast<int>(INT8_C(2)))
+      && (std::numeric_limits<base_class_type::count_type>::digits >= static_cast<int>(INT8_C(32)))
+      && (static_cast<int>(std::numeric_limits<base_class_type::count_type>::digits % static_cast<int>(INT8_C(8))) == static_cast<int>(INT8_C(0))),
+      "Error: The count type must be an unsigned integer with radix 2, that is 32 bits or wider, and having a multiple of 8 bits"
     );
 
-    virtual ~hash_base() = default;
+    ~hash_base() override = default;
 
-    virtual auto initialize() -> void
+    auto initialize() -> void override
     {
-      message_index        = static_cast<std::uint_least16_t>(UINT8_C(0));
+      message_index        = static_cast<std::uint_least32_t>(UINT8_C(0));
       message_length_total = static_cast<count_type>(UINT8_C(0));
 
       message_buffer.fill(static_cast<std::uint8_t>(UINT8_C(0)));
     }
 
-    auto process(const std::uint8_t* message, const count_type count) -> void
+    auto process(const std::uint8_t* message, const count_type count) -> void override
     {
       auto process_index      = count_type { };
       auto process_chunk_size = count_type { };
 
       while(process_index < count)
       {
-        message_index        = static_cast<std::uint_least16_t>(message_index        + process_chunk_size);
+        message_index        = static_cast<std::uint_least32_t>(message_index        + process_chunk_size);
         message_length_total = static_cast<count_type>         (message_length_total + process_chunk_size);
         process_index        = static_cast<count_type>         (process_index        + process_chunk_size);
 
         if(message_index == message_buffer_static_size())
         {
-          my_perform_algorithm();
+          perform_algorithm();
         }
 
         process_chunk_size = (std::min)(static_cast<count_type>(count - process_index),
@@ -72,10 +76,10 @@
       }
     }
 
-    auto finalize() -> void
+    auto finalize() -> void override
     {
       // Create the padding. Begin by setting the leading padding byte to 0x80.
-      message_buffer[message_index] = static_cast<std::uint8_t>(UINT8_C(0x80));
+      message_buffer[static_cast<std::size_t>(message_index)] = static_cast<std::uint8_t>(UINT8_C(0x80));
 
       ++message_index;
 
@@ -86,12 +90,12 @@
       const auto message_top =
         static_cast<std::uint16_t>
         (
-          message_index + static_cast<std::uint_least16_t>(message_length_total_width())
+          message_index + static_cast<std::uint_least32_t>(message_length_total_width())
         );
 
       if(message_top > message_buffer_static_size())
       {
-        my_perform_algorithm();
+        perform_algorithm();
       }
 
       // Encode the total number of bits in the final transform buffer.
@@ -105,10 +109,10 @@
                  ri != message_buffer.rbegin() + static_cast<std::size_t>(message_length_total_width());
                ++ri)
       {
-        const std::uint_least16_t the_word =
-          static_cast<std::uint_least16_t>
+        const std::uint_least32_t the_word =
+          static_cast<std::uint_least32_t>
           (
-            static_cast<std::uint_least16_t>(message_length_total) << static_cast<unsigned>(UINT8_C(3))
+            static_cast<std::uint_least32_t>(message_length_total) << static_cast<unsigned>(UINT8_C(3))
           );
 
         *ri = static_cast<std::uint8_t>(the_word | carry);
@@ -127,7 +131,7 @@
           );
       }
 
-      my_perform_algorithm();
+      perform_algorithm();
     }
 
     auto get_result(typename result_type::pointer result) -> void
@@ -149,7 +153,7 @@
     }
 
   protected:
-    using message_block_type = std::array<std::uint8_t, static_cast<std::size_t>(MessageBufferSize)>;
+    using message_block_type = std::array<std::uint8_t, static_cast<std::size_t>(MessageBlockBufferSize)>;
 
     using context_type = std::array<std::uint32_t, static_cast<std::size_t>(std::tuple_size<result_type>::value / sizeof(std::uint32_t))>;
 
@@ -158,38 +162,38 @@
       return static_cast<std::uint16_t>(std::tuple_size<message_block_type>::value);
     }
 
-    std::uint_least16_t message_index        { };
+    std::uint_least32_t message_index        { };
     count_type          message_length_total { };
     message_block_type  message_buffer       { };
     context_type        transform_context    { };
 
     hash_base() = default;
 
     hash_base(const hash_base&) = default;
-    hash_base(hash_base&&) noexcept = default;
+    hash_base(hash_base&&) = default;
 
     auto operator=(const hash_base& other) -> hash_base& = default;
-    auto operator=(hash_base&& other) noexcept -> hash_base& = default;
+    auto operator=(hash_base&& other) -> hash_base& = default;
 
   private:
-    static constexpr auto message_length_total_width() noexcept -> std::uint16_t
+    static constexpr auto message_length_total_width() -> std::uint16_t
     {
       return
         static_cast<std::uint16_t>
         (
-          MessageLengthTotalBitCount / static_cast<std::uint16_t>(UINT8_C(8))
+          MessageBlockBitCount / static_cast<std::uint16_t>(UINT8_C(8))
         );
     }
 
-    virtual auto perform_algorithm() -> void = 0;
+    virtual auto my_perform_algorithm() -> void = 0;
 
-    auto my_perform_algorithm() -> void
+    auto perform_algorithm() -> void
     {
-      this->perform_algorithm();
+      this->my_perform_algorithm();
 
-      message_index = static_cast<std::uint_least16_t>(UINT8_C(0));
+      message_index = std::uint_least32_t { UINT8_C(0) };
 
-      message_buffer.fill(static_cast<std::uint8_t>(UINT8_C(0)));
+      message_buffer.fill(std::uint8_t { UINT8_C(0) });
     }
   };
 

ref_app/src/math/checksums/hash/hash_detail.h

@@ -1,4 +1,4 @@
-//  Copyright Christopher Kormanyos 2013 - 2025.
+//  Copyright Christopher Kormanyos 2013 - 2026.
 //  Distributed under the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt
 //  or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,6 +9,7 @@
 
   #include <cstddef>
   #include <cstdint>
+  #include <limits>
 
   namespace math { namespace checksums { namespace hash { namespace detail {
 
@@ -36,7 +37,7 @@
       );
   }
 
-  inline auto convert_uint8_input_to_uint32_output(const std::uint8_t* in_begin, const std::uint8_t*  in_end, std::uint32_t* out_begin) -> void
+  constexpr auto convert_uint8_input_to_uint32_output(const std::uint8_t* in_begin, const std::uint8_t*  in_end, std::uint32_t* out_begin) -> void
   {
     // Decode the input uint8_t source into the output uint32_t destination.
     // This subroutine assumes that the length of the input is a multiple of 4.
@@ -60,7 +61,7 @@
     }
   }
 
-  inline auto convert_uint8_input_to_uint32_output_reverse(const std::uint8_t*  in_begin, const std::uint8_t*  in_end, std::uint32_t* out_begin) -> void
+  constexpr auto convert_uint8_input_to_uint32_output_reverse(const std::uint8_t*  in_begin, const std::uint8_t*  in_end, std::uint32_t* out_begin) -> void
   {
     // Decode the input uint8_t source into the output uint32_t destination.
     // This subroutine assumes that the length of the input is a multiple of 4.
@@ -84,7 +85,7 @@
     }
   }
 
-  inline auto convert_uint32_input_to_uint8_output(const std::uint32_t* in_begin, const std::uint32_t* in_end, std::uint8_t*  out_begin) -> void
+  constexpr auto convert_uint32_input_to_uint8_output(const std::uint32_t* in_begin, const std::uint32_t* in_end, std::uint8_t*  out_begin) -> void
   {
     // Encode the input uint32_t source into the output uint8_t destination.
     // This subroutine assumes that the length of the output is a multiple of 4.
@@ -104,7 +105,7 @@
     }
   }
 
-  inline auto convert_uint32_input_to_uint8_output_reverse(const std::uint32_t* in_begin, const std::uint32_t* in_end, std::uint8_t*  out_begin) -> void
+  constexpr auto convert_uint32_input_to_uint8_output_reverse(const std::uint32_t* in_begin, const std::uint32_t* in_end, std::uint8_t*  out_begin) -> void
   {
     // Encode the input uint32_t source into the output uint8_t destination.
     // This subroutine assumes that the length of the output is a multiple of 4.