EIC code displayed by LXR master/​include/​boost/​hash2/​xxh3.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-17 08:46:48

 #ifndef BOOST_HASH2_XXH3_HPP_INCLUDED
 #define BOOST_HASH2_XXH3_HPP_INCLUDED
 
 // Copyright 2025 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 //
 // xxHash, https://cyan4973.github.io/xxHash/
 
 #include <boost/hash2/digest.hpp>
 #include <boost/hash2/detail/byteswap.hpp>
 #include <boost/hash2/detail/is_constant_evaluated.hpp>
 #include <boost/hash2/detail/memset.hpp>
 #include <boost/hash2/detail/memcpy.hpp>
 #include <boost/hash2/detail/mul128.hpp>
 #include <boost/hash2/detail/read.hpp>
 #include <boost/hash2/detail/rot.hpp>
 #include <boost/hash2/detail/write.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <cstdint>
 #include <cstring>
 #include <cstddef>
 
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1920
 # pragma warning(push)
 # pragma warning(disable: 4307) // '+': integral constant overflow
 #endif
 
 namespace boost
 {
 namespace hash2
 {
 
 template<class = void>
 struct xxh3_128_constants
 {
     constexpr static unsigned char const default_secret[ 192 ] =
     {
         0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
         0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
         0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
         0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
         0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
         0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
         0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
         0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
         0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
         0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
         0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
         0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
     };
 };
 
 // copy-paste from Boost.Unordered's prime_fmod approach
 #if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
 
 // https://en.cppreference.com/w/cpp/language/static#Constant_static_members
 // If a const non-inline (since C++17) static data member or a constexpr
 // static data member (since C++11)(until C++17) is odr-used, a definition
 // at namespace scope is still required, but it cannot have an
 // initializer.
 template<class T>
 constexpr unsigned char xxh3_128_constants<T>::default_secret[ 192 ];
 
 #endif
 
 class xxh3_128
 {
 private:
 
     static constexpr std::size_t const default_secret_len = 192;
     static constexpr std::size_t const min_secret_len     = 136;
     static constexpr std::size_t const buffer_size        = 256;
 
     static constexpr std::uint64_t const P32_1     = 0x9E3779B1U;
     static constexpr std::uint64_t const P32_2     = 0x85EBCA77U;
     static constexpr std::uint64_t const P32_3     = 0xC2B2AE3DU;
     static constexpr std::uint64_t const P64_1     = 0x9E3779B185EBCA87ULL;
     static constexpr std::uint64_t const P64_2     = 0xC2B2AE3D27D4EB4FULL;
     static constexpr std::uint64_t const P64_3     = 0x165667B19E3779F9ULL;
     static constexpr std::uint64_t const P64_4     = 0x85EBCA77C2B2AE63ULL;
     static constexpr std::uint64_t const P64_5     = 0x27D4EB2F165667C5ULL;
     static constexpr std::uint64_t const PRIME_MX1 = 0x165667919E3779F9ULL;
     static constexpr std::uint64_t const PRIME_MX2 = 0x9FB21C651E98DF25ULL;
 
     BOOST_CXX14_CONSTEXPR void init_secret_from_seed( std::uint64_t seed )
     {
         auto const secret = xxh3_128_constants<>::default_secret;
 
         std::size_t num_rounds = default_secret_len / 16;
         for( std::size_t i = 0; i < num_rounds; ++i )
         {
             auto low  = detail::read64le( secret + 16 * i ) + seed;
             auto high = detail::read64le( secret + 16 * i + 8 ) - seed;
 
             detail::write64le( secret_ + 16 * i, low );
             detail::write64le( secret_ + 16 * i + 8, high );
         }
     }
 
     BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR static std::uint64_t avalanche( std::uint64_t x )
     {
         x ^= ( x >> 37 );
         x *= PRIME_MX1;
         x ^= ( x >> 32 );
         return x;
     }
 
     BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR static std::uint64_t avalanche_xxh64( std::uint64_t x )
     {
         x ^= x >> 33;
         x *= P64_2;
         x ^= x >> 29;
         x *= P64_3;
         x ^= x >> 32;
         return x;
     }
 
     BOOST_CXX14_CONSTEXPR std::uint64_t mix_step( unsigned char const* data, std::size_t secret_offset, std::uint64_t seed )
     {
         auto const secret = with_secret_? secret_: xxh3_128_constants<>::default_secret;
 
         std::uint64_t data_words[ 2 ] = {};
         std::uint64_t secret_words[ 2 ] = {};
         for( int i = 0; i < 2; ++i )
         {
             data_words[ i ] = detail::read64le( data + 8 * i );
             secret_words[ i ] = detail::read64le( secret + secret_offset + 8 * i );
         }
 
         detail::uint128 r = detail::mul128( data_words[ 0 ] ^ ( secret_words[ 0 ] + seed ), data_words[ 1 ] ^ ( secret_words[ 1 ] - seed ) );
         return r.low ^ r.high;
     }
 
     BOOST_CXX14_CONSTEXPR void mix_two_chunks( unsigned char const* x, unsigned char const* y, std::size_t secret_offset, std::uint64_t seed, std::uint64_t (&acc)[ 2 ] )
     {
         std::uint64_t data_words1[ 2 ] = {};
         std::uint64_t data_words2[ 2 ] = {};
 
         for( int i = 0; i < 2; ++i )
         {
             data_words1[ i ] = detail::read64le( x + 8 * i );
             data_words2[ i ] = detail::read64le( y + 8 * i );
         }
 
         acc[ 0 ] += mix_step( x, secret_offset, seed );
         acc[ 1 ] += mix_step( y, secret_offset + 16, seed );
         acc[ 0 ] ^= ( data_words2[ 0 ] + data_words2[ 1 ] );
         acc[ 1 ] ^= ( data_words1[ 0 ] + data_words1[ 1 ] );
     }
 
     BOOST_CXX14_CONSTEXPR void accumulate( std::uint64_t stripe[ 8 ], std::size_t secret_offset )
     {
         std::uint64_t secret_words[ 8 ] = {};
         for( int i = 0; i < 8; ++i )
         {
             secret_words[ i ] = detail::read64le( secret_ + secret_offset + 8 * i );
         }
 
         for( int i = 0; i < 8; ++i )
         {
             std::uint64_t value = stripe[ i ] ^ secret_words[ i ];
             acc_[ i ^ 1 ] = acc_[ i ^ 1 ] + stripe[ i ];
             acc_[ i ] = acc_[ i ] + ( value & 0xffffffff ) * ( value >> 32 );
         }
     }
 
     BOOST_CXX14_CONSTEXPR void scramble()
     {
         std::uint64_t secret_words[ 8 ] = {};
         for( int i = 0; i < 8; ++i )
         {
             secret_words[ i ] = detail::read64le( secret_ + ( secret_len_ - 64 ) + ( 8 * i ) );
         }
 
         for( int i = 0; i < 8; ++i )
         {
             acc_[ i ] ^= acc_[ i ] >> 47;
             acc_[ i ] ^= secret_words[ i ];
             acc_[ i ] *= P32_1;
         }
     }
 
     BOOST_CXX14_CONSTEXPR void last_round()
     {
         unsigned char last_stripe[ 64 ] = {};
         unsigned char* last_stripe_ptr = nullptr;
 
         if( m_ >= 64 )
         {
             std::size_t num_stripes = ( m_ == 0 ? 0 : ( m_ - 1 ) / 64 );
             for( std::size_t n = 0; n < num_stripes; ++n )
             {
                 std::uint64_t stripe[ 8 ] = {};
                 for( int i = 0; i < 8; ++i )
                 {
                     stripe[ i ] = detail::read64le( buffer_ + ( 64 * n ) + ( 8 * i ) );
                 }
                 accumulate( stripe, 8 * num_stripes_++ );
 
                 std::size_t const stripes_per_block_ = ( secret_len_ - 64 ) / 8;
                 (void)stripes_per_block_;
 
                 BOOST_ASSERT( num_stripes_ <= stripes_per_block_ );
             }
 
             last_stripe_ptr = buffer_ + m_ - 64;
         }
         else
         {
             std::size_t len = 64 - m_;
 
             detail::memcpy( last_stripe, buffer_ + buffer_size - len, len );
             detail::memcpy( last_stripe + len, buffer_, m_ );
 
             last_stripe_ptr = last_stripe;
         }
 
         std::uint64_t stripe[ 8 ] = {};
         for( int i = 0; i < 8; ++i )
         {
             stripe[ i ] = detail::read64le( last_stripe_ptr + ( 8 * i ) );
         }
 
         accumulate( stripe, secret_len_ - 71 );
     }
 
     BOOST_CXX14_CONSTEXPR std::uint64_t final_merge( std::uint64_t init_value, std::size_t secret_offset )
     {
         std::uint64_t secret_words[ 8 ] = {};
         for( int i = 0; i < 8; ++i )
         {
             secret_words[ i ] = detail::read64le( secret_ + secret_offset + 8 * i );
         }
 
         std::uint64_t result = init_value;
         for( int i = 0; i < 4; ++i )
         {
             auto mul_result = detail::mul128( acc_[ 2 * i ] ^ secret_words[ 2 * i ], acc_[ 2 * i + 1 ] ^ secret_words[ 2 * i + 1 ] );
             result += mul_result.low ^ mul_result.high;
         }
 
         return avalanche( result );
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_empty()
     {
         auto const secret = with_secret_? secret_: xxh3_128_constants<>::default_secret;
 
         std::uint64_t secret_words[ 4 ] = {};
         for( int i = 0; i < 4; ++i )
         {
             secret_words[ i ] = detail::read64le( secret + 64 + 8 * i );
         }
 
         digest<16> r;
         detail::write64be( r.data() + 8, avalanche_xxh64( seed_ ^ secret_words[ 0 ] ^ secret_words[ 1 ] ) );
         detail::write64be( r.data() + 0, avalanche_xxh64( seed_ ^ secret_words[ 2 ] ^ secret_words[ 3 ] ) );
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_1to3()
     {
         auto const secret = with_secret_? secret_: xxh3_128_constants<>::default_secret;
 
         std::uint32_t v1 = buffer_[ ( n_ - 1 ) ];
         std::uint32_t v2 = static_cast<std::uint32_t>( n_ << 8 );
         std::uint32_t v3 = buffer_[ 0 ] << 16;
         std::uint32_t v4 = buffer_[ ( n_ >> 1 ) ] << 24;
 
         std::uint32_t combined = v1 | v2 | v3 | v4;
 
         std::uint32_t secret_words[ 4 ] = {};
         for( int i = 0; i < 4; ++i )
         {
             secret_words[ i ] = detail::read32le( secret + 4 * i );
         }
 
         std::uint64_t low  = ( ( secret_words[ 0 ] ^ secret_words[ 1 ] ) + seed_ ) ^ combined;
         std::uint64_t high = ( ( secret_words[ 2 ] ^ secret_words[ 3 ] ) - seed_ ) ^ ( detail::rotl( detail::byteswap( combined ), 13 ) );
 
         digest<16> r;
         detail::write64be( r.data() + 8, avalanche_xxh64( low ) );
         detail::write64be( r.data() + 0, avalanche_xxh64( high ) );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_4to8()
     {
         auto const secret = with_secret_? secret_: xxh3_128_constants<>::default_secret;
 
         std::uint32_t input_first = detail::read32le( buffer_ );
         std::uint32_t input_last  = detail::read32le( buffer_ + ( n_ - 4 ) );
         std::uint64_t modified_seed = seed_ ^ ( std::uint64_t{ detail::byteswap( static_cast<std::uint32_t>( seed_ ) ) } << 32 );
 
         std::uint64_t secret_words[ 2 ] = {};
         for( int i = 0; i < 2; ++i )
         {
             secret_words[ i ] = detail::read64le( secret + 16 + i * 8 );
         }
 
         std::uint64_t combined = std::uint64_t{ input_first } | ( std::uint64_t{ input_last } << 32 );
         std::uint64_t value = ( ( secret_words[ 0 ] ^ secret_words[ 1 ] ) + modified_seed ) ^ combined;
 
         detail::uint128 mul_result = detail::mul128( value, P64_1 + ( n_ << 2 ) );
         std::uint64_t high = mul_result.high;
         std::uint64_t low = mul_result.low;
 
         high += ( low << 1 );
         low ^= ( high >> 3 );
         low ^= ( low >> 35 );
         low *= PRIME_MX2;
         low ^= ( low >> 28 );
 
         high = avalanche( high );
 
         digest<16> r;
         detail::write64be( r.data() + 0, high );
         detail::write64be( r.data() + 8, low );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_9to16()
     {
         auto const secret = with_secret_? secret_: xxh3_128_constants<>::default_secret;
 
         std::uint64_t input_first = detail::read64le( buffer_ );
         std::uint64_t input_last = detail::read64le( buffer_ + ( n_ - 8 ) );
 
         std::uint64_t secret_words[ 4 ] = {};
         for( int i = 0; i < 4; ++i )
         {
             secret_words[ i ] = detail::read64le( secret + 32 + ( i * 8 ) );
         }
 
         std::uint64_t val1 = ( ( secret_words[ 0 ] ^ secret_words[ 1 ] ) - seed_ ) ^ input_first ^ input_last;
         std::uint64_t val2 = ( ( secret_words[ 2 ] ^ secret_words[ 3 ] ) + seed_ ) ^ input_last;
 
         detail::uint128 mul_result = detail::mul128( val1, P64_1 );
         std::uint64_t low = mul_result.low + ( std::uint64_t{ n_ - 1 } << 54 );
         std::uint64_t high = mul_result.high + val2 + ( val2 & 0x00000000ffffffff ) * ( P32_2 - 1 );
 
         low ^= detail::byteswap( high );
 
         detail::uint128 mul_result2 = detail::mul128( low, P64_2 );
         low = mul_result2.low;
         high = mul_result2.high + high * P64_2;
 
         digest<16> r;
         detail::write64be( r.data() + 0, avalanche( high ) );
         detail::write64be( r.data() + 8, avalanche( low ) );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_17to128()
     {
         std::uint64_t acc[ 2 ] = { n_ * P64_1, 0 };
 
         std::uint64_t num_rounds = ( ( n_ - 1 ) >> 5 ) + 1;
         for( std::int64_t i = num_rounds - 1; i >= 0; --i )
         {
             std::size_t offset_start = static_cast<std::size_t>( 16 * i );
             std::size_t offset_end = n_ - static_cast<std::size_t>( 16 * i ) - 16;
 
             mix_two_chunks( buffer_ + offset_start, buffer_ + offset_end, static_cast<std::size_t>( 32 * i ), seed_, acc );
         }
 
         std::uint64_t low = acc[ 0 ] + acc[ 1 ];
         std::uint64_t high = ( acc[ 0 ] * P64_1 ) + ( acc[ 1 ] * P64_4 ) + ( ( std::uint64_t{ n_ } - seed_ ) * P64_2 );
 
         digest<16> r;
         detail::write64be( r.data() + 0, std::uint64_t{ 0 } - avalanche( high ) );
         detail::write64be( r.data() + 8, avalanche( low ) );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_129to240()
     {
         std::uint64_t acc[ 2 ] = { n_ * P64_1, 0 };
 
         std::uint64_t num_chunks = n_ >> 5;
 
         for( std::size_t i = 0; i < 4; ++i )
         {
             mix_two_chunks( buffer_ + 32 * i, buffer_ + ( 32 * i ) + 16, 32 * i, seed_, acc );
         }
 
         acc[ 0 ] = avalanche( acc[ 0 ] );
         acc[ 1 ] = avalanche( acc[ 1 ] );
 
         for( std::size_t i = 4; i < num_chunks; ++i )
         {
             mix_two_chunks( buffer_ + 32 * i, buffer_ + ( 32 * i ) + 16, ( i - 4 ) * 32 + 3, seed_, acc );
         }
 
         mix_two_chunks( buffer_ + n_ - 16, buffer_ + n_ - 32, 103, std::uint64_t{ 0 } - seed_, acc );
 
         std::uint64_t low = acc[ 0 ] + acc[ 1 ];
         std::uint64_t high = ( acc[ 0 ] * P64_1 ) + ( acc[ 1 ] * P64_4 ) + ( ( std::uint64_t{ n_ } - seed_ ) * P64_2 );
 
         digest<16> r;
         detail::write64be( r.data() + 0, std::uint64_t{ 0 } - avalanche( high ) );
         detail::write64be( r.data() + 8, avalanche( low ) );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR digest<16> xxh3_128_digest_long()
     {
         last_round();
 
         std::uint64_t low = final_merge( n_ * P64_1, 11 );
         std::uint64_t high = final_merge( ~( n_ * P64_2 ), secret_len_ - 75 );
 
         digest<16> r;
         detail::write64be( r.data() + 0, high );
         detail::write64be( r.data() + 8, low );
 
         return r;
     }
 
     BOOST_CXX14_CONSTEXPR static std::uint64_t combine( std::uint64_t v1, std::uint64_t v2 )
     {
         return avalanche( v1 + v2 );
     }
 
 private:
 
     unsigned char secret_[ default_secret_len ] = {};
     std::uint64_t seed_ = 0;
     bool with_secret_ = false;
 
     unsigned char buffer_[ buffer_size ] = {};
 
     std::uint64_t acc_[ 8 ] = { P32_3, P64_1, P64_2, P64_3, P64_4, P32_2, P64_5, P32_1 };
 
     std::size_t n_ = 0;
     std::size_t m_ = 0;
 
     std::size_t secret_len_ = default_secret_len;
 
     std::size_t num_stripes_ = 0; // current number of processed stripes
 
 public:
 
     using result_type = digest<16>;
 
     BOOST_CXX14_CONSTEXPR xxh3_128()
     {
         detail::memcpy( secret_, xxh3_128_constants<>::default_secret, default_secret_len );
     }
 
     BOOST_CXX14_CONSTEXPR explicit xxh3_128( std::uint64_t seed ): seed_( seed )
     {
         init_secret_from_seed( seed );
     }
 
     xxh3_128( void const* p, std::size_t n ): xxh3_128( static_cast<unsigned char const*>( p ), n )
     {
     }
 
     BOOST_CXX14_CONSTEXPR xxh3_128( unsigned char const* p, std::size_t n )
     {
         detail::memcpy( secret_, xxh3_128_constants<>::default_secret, default_secret_len );
 
         if( n == 0 ) return;
 
         with_secret_ = true;
 
         std::size_t const n2 = n;
         std::uint64_t seed = 0;
 
         while( n >= default_secret_len )
         {
             for( std::size_t i = 0; i < default_secret_len / 8; ++i )
             {
                 std::uint64_t v1 = detail::read64le( p + i * 8 );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, combine( v1, v2 ) );
 
                 seed = combine( seed, v1 );
             }
 
             p += default_secret_len;
             n -= default_secret_len;
         }
 
         {
             std::size_t i = 0;
 
             for( ; i < n / 8; ++i )
             {
                 std::uint64_t v1 = detail::read64le( p + i * 8 );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, combine( v1, v2 ) );
 
                 seed = combine( seed, v1 );
             }
 
             n = n % 8;
 
             if( n > 0 )
             {
                 unsigned char w[ 8 ] = {};
                 detail::memcpy( w, p + i * 8, n );
 
                 std::uint64_t v1 = detail::read64le( w );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, combine( v1, v2 ) );
 
                 seed = combine( seed, v1 );
             }
         }
 
         {
             std::size_t const i = 0;
 
             std::uint64_t v1 = n2;
             std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
             detail::write64le( secret_ + i * 8, combine( v1, v2 ) );
 
             seed = combine( seed, v1 );
         }
 
         seed_ = seed;
     }
 
 private: // supporting constructor for the static factory functions
 
     BOOST_CXX14_CONSTEXPR xxh3_128( std::uint64_t seed, unsigned char const* p, std::size_t n, bool with_secret ): seed_( seed ), with_secret_( with_secret )
     {
         if( n < min_secret_len )
         {
             // this is a precondition violation for XXH3, but we try to do something reasonable
             detail::memcpy( secret_, xxh3_128_constants<>::default_secret, default_secret_len );
             secret_len_ = default_secret_len;
         }
         else if( n < default_secret_len )
         {
             secret_len_ = n;
         }
         else
         {
             secret_len_ = default_secret_len;
         }
 
         // incorporate passed secret into secret_
         // in the case where min_secret_len <= n <= default_secret_len,
         //  this is a simple copy because the initial secret_ is {}
 
         while( n >= default_secret_len )
         {
             for( std::size_t i = 0; i < default_secret_len / 8; ++i )
             {
                 std::uint64_t v1 = detail::read64le( p + i * 8 );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, v1 + v2 );
             }
 
             p += default_secret_len;
             n -= default_secret_len;
         }
 
         {
             std::size_t i = 0;
 
             for( ; i < n / 8; ++i )
             {
                 std::uint64_t v1 = detail::read64le( p + i * 8 );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, v1 + v2 );
             }
 
             n = n % 8;
 
             if( n > 0 )
             {
                 unsigned char w[ 8 ] = {};
                 detail::memcpy( w, p + i * 8, n );
 
                 std::uint64_t v1 = detail::read64le( w );
                 std::uint64_t v2 = detail::read64le( secret_ + i * 8 );
 
                 detail::write64le( secret_ + i * 8, v1 + v2 );
             }
         }
     }
 
 public:
 
     // XXH3-specific named constructors, matching the reference implementation
 
     // for completeness only
     static BOOST_CXX14_CONSTEXPR xxh3_128 with_seed( std::uint64_t seed )
     {
         return xxh3_128( seed );
     }
 
     static BOOST_CXX14_CONSTEXPR xxh3_128 with_secret( unsigned char const* p, std::size_t n )
     {
         return xxh3_128( 0, p, n, true );
     }
 
     static xxh3_128 with_secret( void const* p, std::size_t n )
     {
         return with_secret( static_cast<unsigned char const*>( p ), n );
     }
 
     static BOOST_CXX14_CONSTEXPR xxh3_128 with_secret_and_seed( unsigned char const* p, std::size_t n, std::uint64_t seed )
     {
         return xxh3_128( seed, p, n, false );
     }
 
     static xxh3_128 with_secret_and_seed( void const* p, std::size_t n, std::uint64_t seed )
     {
         return with_secret_and_seed( static_cast<unsigned char const*>( p ), n, seed );
     }
 
     void update( void const* p, std::size_t n )
     {
         update( static_cast<unsigned char const*>( p ), n );
     }
 
     BOOST_CXX14_CONSTEXPR void update( unsigned char const* p, std::size_t n )
     {
         if( n == 0 ) return;
 
         std::size_t const stripes_per_block_ = ( secret_len_ - 64 ) / 8;
 
         n_ += n;
 
         if( n <= buffer_size - m_ )
         {
             detail::memcpy( buffer_ + m_, p, n );
             m_ += n;
             return;
         }
 
         if( m_ > 0 )
         {
             std::size_t k = buffer_size - m_;
             detail::memcpy( buffer_ + m_, p, k );
 
             p += k;
             n -= k;
 
             for( std::size_t i = 0; i < 4; ++i )
             {
                 std::uint64_t stripe[ 8 ] = {};
                 for( int j = 0; j < 8; ++j )
                 {
                     stripe[ j ] = detail::read64le( buffer_ + ( 64 * i)  + ( 8 * j ) );
                 }
                 accumulate( stripe, 8 * num_stripes_ );
                 ++num_stripes_;
 
                 if( num_stripes_ == stripes_per_block_ )
                 {
                     scramble();
                     num_stripes_ = 0;
                 }
             }
 
             m_ = 0;
         }
 
         if( n > buffer_size )
         {
             while( n > 64 )
             {
                 std::uint64_t stripe[ 8 ] = {};
                 for( int j = 0; j < 8; ++j )
                 {
                     stripe[ j ] = detail::read64le( p + ( 8 * j ) );
                 }
                 accumulate( stripe, 8 * num_stripes_ );
                 ++num_stripes_;
 
                 if( num_stripes_ == stripes_per_block_ )
                 {
                     scramble();
                     num_stripes_ = 0;
                 }
 
                 p += 64;
                 n -= 64;
             }
 
             detail::memcpy( buffer_ + buffer_size - 64, p - 64, 64 );
 
             BOOST_ASSERT( n <= 64 );
         }
 
         if( n > 0 )
         {
             detail::memcpy( buffer_, p, n );
             m_ = n;
         }
     }
 
     BOOST_CXX14_CONSTEXPR result_type result()
     {
         result_type r;
 
         if( n_ == 0 )
         {
            r = xxh3_128_digest_empty();
 
             // perturb state to enable result extension
             seed_ += P64_5;
         }
         else if( n_ < 4 )
         {
             r = xxh3_128_digest_1to3();
         }
         else if( n_ < 9 )
         {
             r = xxh3_128_digest_4to8();
         }
         else if( n_ < 17 )
         {
             r = xxh3_128_digest_9to16();
         }
         else if( n_ < 129 )
         {
             r = xxh3_128_digest_17to128();
         }
         else if( n_ < 241 )
         {
             r = xxh3_128_digest_129to240();
         }
         else
         {
             r = xxh3_128_digest_long();
 
             // perturb state to enable result extension
             acc_[ 0 ] -= P64_1;
             acc_[ 1 ] += P64_1;
             acc_[ 2 ] -= P64_2;
             acc_[ 3 ] += P64_2;
             acc_[ 4 ] -= P64_3;
             acc_[ 5 ] += P64_3;
             acc_[ 6 ] -= P64_4;
             acc_[ 7 ] += P64_4;
         }
 
         // finalize buffer to clear plainext and enable result extension
 
         {
             std::uint64_t h1 = detail::read64le( r.data() + 0 );
             std::uint64_t h2 = detail::read64le( r.data() + 8 );
 
             std::uint64_t v1 = detail::read64le( buffer_ + 0 );
             detail::write64le( buffer_ + 0, v1 + h1 );
 
             std::uint64_t v2 = detail::read64le( buffer_ + 8 );
             detail::write64le( buffer_ + 8, v2 + h2 );
 
             detail::memset( buffer_ + 16, 0, buffer_size - 16 );
         }
 
         return r;
     }
 };
 
 } // namespace hash2
 } // namespace boost
 
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1920
 # pragma warning(pop)
 #endif
 
 #endif // #ifndef BOOST_HASH2_XXH3_HPP_INCLUDED

This page was automatically generated by the 2.3.7 LXR engine. The LXR team