+++ /dev/null
-#pragma once
-#include <array>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include <iostream>
-
-/*
-xxHash - Extremely Fast Hash algorithm
-Header File
-Copyright (C) 2012-2018, Yann Collet.
-Copyright (C) 2017-2018, Piotr Pliszka.
-All rights reserved.
-
-BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-* Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-You can contact the author at :
-- xxHash source repository : https://github.com/Cyan4973/xxHash
-- xxHash C++ port repository : https://github.com/RedSpah/xxhash_cpp
-*/
-
-/* *************************************
- * Tuning parameters
- ***************************************/
-/*!XXH_FORCE_MEMORY_ACCESS :
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
- * It can generate buggy code on targets which do not support unaligned memory accesses.
- * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://stackoverflow.com/a/32095106/646947 for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */
-#if defined(__GNUC__) && (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || \
- defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__))
-#define XXH_FORCE_MEMORY_ACCESS 2
-#elif defined(__INTEL_COMPILER) || \
- (defined(__GNUC__) && (defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || \
- defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)))
-#define XXH_FORCE_MEMORY_ACCESS 1
-#endif
-#endif
-
-/*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
- * Results are therefore identical for little-endian and big-endian CPU.
- * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independence be of no importance for your application, you may set the #define below to 1,
- * to improve speed for Big-endian CPU.
- * This option has no impact on Little_Endian CPU.
- */
-#if !defined(XXH_FORCE_NATIVE_FORMAT) || (XXH_FORCE_NATIVE_FORMAT == 0) /* can be defined externally */
-#define XXH_FORCE_NATIVE_FORMAT 0
-#define XXH_CPU_LITTLE_ENDIAN 1
-#endif
-
-/*!XXH_FORCE_ALIGN_CHECK :
- * This is a minor performance trick, only useful with lots of very small keys.
- * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash;
- * set it to 0 when the input is guaranteed to be aligned,
- * or when alignment doesn't matter for performance.
- */
-#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#define XXH_FORCE_ALIGN_CHECK 0
-#else
-#define XXH_FORCE_ALIGN_CHECK 1
-#endif
-#endif
-
-/*!XXH_CPU_LITTLE_ENDIAN :
- * This is a CPU endian detection macro, will be
- * automatically set to 1 (little endian) if XXH_FORCE_NATIVE_FORMAT
- * is left undefined, XXH_FORCE_NATIVE_FORMAT is defined to 0, or if an x86/x86_64 compiler macro is defined.
- * If left undefined, endianness will be determined at runtime, at the cost of a slight one-time overhead
- * and a larger overhead due to get_endian() not being constexpr.
- */
-#ifndef XXH_CPU_LITTLE_ENDIAN
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#define XXH_CPU_LITTLE_ENDIAN 1
-#endif
-#endif
-
-/* *************************************
- * Compiler Specific Options
- ***************************************/
-#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-
-namespace xxh {
-/* *************************************
- * Version
- ***************************************/
-constexpr int cpp_version_major = 0;
-constexpr int cpp_version_minor = 6;
-constexpr int cpp_version_release = 5;
-constexpr uint32_t version_number()
-{
- return cpp_version_major * 10000 + cpp_version_minor * 100 + cpp_version_release;
-}
-
-namespace hash_t_impl {
-/* *************************************
- * Basic Types - Detail
- ***************************************/
-
-using _hash32_underlying = uint32_t;
-using _hash64_underlying = uint64_t;
-
-template <size_t N> struct hash_type {
- using type = void;
-};
-template <> struct hash_type<32> {
- using type = _hash32_underlying;
-};
-template <> struct hash_type<64> {
- using type = _hash64_underlying;
-};
-} // namespace hash_t_impl
-
-/* *************************************
- * Basic Types - Public
- ***************************************/
-
-template <size_t N> using hash_t = typename hash_t_impl::hash_type<N>::type;
-using hash32_t = hash_t<32>;
-using hash64_t = hash_t<64>;
-
-/* *************************************
- * Bit Functions - Public
- ***************************************/
-
-namespace bit_ops {
-/* ****************************************
- * Intrinsics and Bit Operations
- ******************************************/
-
-#if defined(_MSC_VER)
-inline uint32_t rotl32(uint32_t x, int32_t r)
-{
- return _rotl(x, r);
-}
-inline uint64_t rotl64(uint64_t x, int32_t r)
-{
- return _rotl64(x, r);
-}
-#else
-inline uint32_t rotl32(uint32_t x, int32_t r)
-{
- return ((x << r) | (x >> (32 - r)));
-}
-inline uint64_t rotl64(uint64_t x, int32_t r)
-{
- return ((x << r) | (x >> (64 - r)));
-}
-#endif
-
-#if defined(_MSC_VER) /* Visual Studio */
-inline uint32_t swap32(uint32_t x)
-{
- return _byteswap_ulong(x);
-}
-inline uint64_t swap64(uint64_t x)
-{
- return _byteswap_uint64(x);
-}
-#elif XXH_GCC_VERSION >= 403
-inline uint32_t swap32(uint32_t x)
-{
- return __builtin_bswap32(x);
-}
-inline uint64_t swap64(uint64_t x)
-{
- return __builtin_bswap64(x);
-}
-#else
-inline uint32_t swap32(uint32_t x)
-{
- return ((x << 24) & 0xff000000) | ((x << 8) & 0x00ff0000) | ((x >> 8) & 0x0000ff00) | ((x >> 24) & 0x000000ff);
-}
-inline uint64_t swap64(uint64_t x)
-{
- return ((x << 56) & 0xff00000000000000ULL) | ((x << 40) & 0x00ff000000000000ULL) |
- ((x << 24) & 0x0000ff0000000000ULL) | ((x << 8) & 0x000000ff00000000ULL) | ((x >> 8) & 0x00000000ff000000ULL) |
- ((x >> 24) & 0x0000000000ff0000ULL) | ((x >> 40) & 0x000000000000ff00ULL) |
- ((x >> 56) & 0x00000000000000ffULL);
-}
-#endif
-template <size_t N> inline hash_t<N> rotl(hash_t<N> n, int32_t r){};
-
-template <> inline hash_t<32> rotl<32>(hash_t<32> n, int32_t r)
-{
- return rotl32(n, r);
-};
-
-template <> inline hash_t<64> rotl<64>(hash_t<64> n, int32_t r)
-{
- return rotl64(n, r);
-};
-
-template <size_t N> inline hash_t<N> swap(hash_t<N> n){};
-
-template <> inline hash_t<32> swap<32>(hash_t<32> n)
-{
- return swap32(n);
-};
-
-template <> inline hash_t<64> swap<64>(hash_t<64> n)
-{
- return swap64(n);
-};
-} // namespace bit_ops
-
-/* *************************************
- * Memory Functions - Public
- ***************************************/
-
-enum class alignment : uint8_t { aligned, unaligned };
-enum class endianness : uint8_t { big_endian = 0, little_endian = 1, unspecified = 2 };
-
-namespace mem_ops {
-/* *************************************
- * Memory Access
- ***************************************/
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS == 2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-template <size_t N> inline hash_t<N> read_unaligned(const void* memPtr)
-{
- return *(const hash_t<N>*)memPtr;
-}
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS == 1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-template <size_t N> using unalign = union {
- hash_t<N> uval;
-} __attribute((packed));
-
-template <size_t N> inline hash_t<N> read_unaligned(const void* memPtr)
-{
- return ((const unalign*)memPtr)->uval;
-}
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-template <size_t N> inline hash_t<N> read_unaligned(const void* memPtr)
-{
- hash_t<N> val;
- memcpy(&val, memPtr, sizeof(val));
- return val;
-}
-
-#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-inline hash_t<32> read32(const void* memPtr)
-{
- return read_unaligned<32>(memPtr);
-}
-inline hash_t<64> read64(const void* memPtr)
-{
- return read_unaligned<64>(memPtr);
-}
-
-/* *************************************
- * Architecture Macros
- ***************************************/
-
-/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
-
-#ifndef XXH_CPU_LITTLE_ENDIAN
-
-inline endianness get_endian(endianness endian)
-{
- static struct _dummy_t {
- std::array<endianness, 3> endian_lookup = {endianness::big_endian, endianness::little_endian,
- endianness::unspecified};
- const int g_one = 1;
- _dummy_t() { endian_lookup[2] = static_cast<endianness>(*(const char*)(&g_one)); }
- } _dummy;
-
- return _dummy.endian_lookup[(uint8_t)endian];
-}
-
-inline bool is_little_endian()
-{
- return get_endian(endianness::unspecified) == endianness::little_endian;
-}
-
-#else
-constexpr endianness get_endian(endianness endian)
-{
- constexpr std::array<endianness, 3> endian_lookup = {
- {endianness::big_endian, endianness::little_endian,
- (XXH_CPU_LITTLE_ENDIAN) ? endianness::little_endian : endianness::big_endian}};
- return endian_lookup[static_cast<uint8_t>(endian)];
-}
-
-constexpr bool is_little_endian()
-{
- return get_endian(endianness::unspecified) == endianness::little_endian;
-}
-
-#endif
-
-/* ***************************
- * Memory reads
- *****************************/
-
-template <size_t N> inline hash_t<N> readLE_align(const void* ptr, endianness endian, alignment align)
-{
- if (align == alignment::unaligned) {
- return endian == endianness::little_endian ? read_unaligned<N>(ptr) : bit_ops::swap<N>(read_unaligned<N>(ptr));
- } else {
- return endian == endianness::little_endian ? *reinterpret_cast<const hash_t<N>*>(ptr)
- : bit_ops::swap<N>(*reinterpret_cast<const hash_t<N>*>(ptr));
- }
-}
-
-template <size_t N> inline hash_t<N> readLE(const void* ptr, endianness endian)
-{
- return readLE_align<N>(ptr, endian, alignment::unaligned);
-}
-
-template <size_t N> inline hash_t<N> readBE(const void* ptr)
-{
- return is_little_endian() ? bit_ops::swap<N>(read_unaligned<N>(ptr)) : read_unaligned<N>(ptr);
-}
-
-template <size_t N> inline alignment get_alignment(const void* input)
-{
- return ((XXH_FORCE_ALIGN_CHECK) && ((reinterpret_cast<uintptr_t>(input) & ((N / 8) - 1)) == 0))
- ? xxh::alignment::aligned
- : xxh::alignment::unaligned;
-}
-} // namespace mem_ops
-
-/* *******************************************************************
- * Hash functions
- *********************************************************************/
-
-namespace detail {
-/* *******************************************************************
- * Hash functions - Implementation
- *********************************************************************/
-
-constexpr static std::array<hash32_t, 5> primes32 = {{2654435761U, 2246822519U, 3266489917U, 668265263U, 374761393U}};
-constexpr static std::array<hash64_t, 5> primes64 = {{11400714785074694791ULL, 14029467366897019727ULL,
- 1609587929392839161ULL, 9650029242287828579ULL,
- 2870177450012600261ULL}};
-
-template <size_t N> constexpr hash_t<N> PRIME(int32_t n){};
-
-template <> constexpr hash32_t PRIME<32>(int32_t n)
-{
- return primes32[n - 1];
-}
-
-template <> constexpr hash64_t PRIME<64>(int32_t n)
-{
- return primes64[n - 1];
-}
-
-template <size_t N> inline hash_t<N> round(hash_t<N> seed, hash_t<N> input)
-{
- seed += input * PRIME<N>(2);
- seed = bit_ops::rotl<N>(seed, ((N == 32) ? 13 : 31));
- seed *= PRIME<N>(1);
- return seed;
-}
-
-inline hash64_t mergeRound64(hash64_t acc, hash64_t val)
-{
- val = round<64>(0, val);
- acc ^= val;
- acc = acc * PRIME<64>(1) + PRIME<64>(4);
- return acc;
-}
-
-template <size_t N>
-inline void endian_align_sub_mergeround(
-#if __cplusplus < 201703L
- __attribute__((unused))
-#else
- [[maybe_unused]]
-#endif
- hash_t<N>& hash_ret,
- hash_t<N> v1, hash_t<N> v2, hash_t<N> v3, hash_t<N> v4){};
-
-template <>
-inline void endian_align_sub_mergeround<64>(hash_t<64>& hash_ret, hash_t<64> v1, hash_t<64> v2, hash_t<64> v3,
- hash_t<64> v4)
-{
- hash_ret = mergeRound64(hash_ret, v1);
- hash_ret = mergeRound64(hash_ret, v2);
- hash_ret = mergeRound64(hash_ret, v3);
- hash_ret = mergeRound64(hash_ret, v4);
-}
-
-template <size_t N>
-inline hash_t<N> endian_align_sub_ending(hash_t<N> hash_ret, const uint8_t* p, const uint8_t* bEnd,
- xxh::endianness endian, xxh::alignment align){};
-
-template <>
-inline hash_t<32> endian_align_sub_ending<32>(hash_t<32> hash_ret, const uint8_t* p, const uint8_t* bEnd,
- xxh::endianness endian, xxh::alignment align)
-{
- while ((p + 4) <= bEnd) {
- hash_ret += mem_ops::readLE_align<32>(p, endian, align) * PRIME<32>(3);
- hash_ret = bit_ops::rotl<32>(hash_ret, 17) * PRIME<32>(4);
- p += 4;
- }
-
- while (p < bEnd) {
- hash_ret += (*p) * PRIME<32>(5);
- hash_ret = bit_ops::rotl<32>(hash_ret, 11) * PRIME<32>(1);
- p++;
- }
-
- hash_ret ^= hash_ret >> 15;
- hash_ret *= PRIME<32>(2);
- hash_ret ^= hash_ret >> 13;
- hash_ret *= PRIME<32>(3);
- hash_ret ^= hash_ret >> 16;
-
- return hash_ret;
-}
-
-template <>
-inline hash_t<64> endian_align_sub_ending<64>(hash_t<64> hash_ret, const uint8_t* p, const uint8_t* bEnd,
- xxh::endianness endian, xxh::alignment align)
-{
- while (p + 8 <= bEnd) {
- const hash64_t k1 = round<64>(0, mem_ops::readLE_align<64>(p, endian, align));
- hash_ret ^= k1;
- hash_ret = bit_ops::rotl<64>(hash_ret, 27) * PRIME<64>(1) + PRIME<64>(4);
- p += 8;
- }
-
- if (p + 4 <= bEnd) {
- hash_ret ^= static_cast<hash64_t>(mem_ops::readLE_align<32>(p, endian, align)) * PRIME<64>(1);
- hash_ret = bit_ops::rotl<64>(hash_ret, 23) * PRIME<64>(2) + PRIME<64>(3);
- p += 4;
- }
-
- while (p < bEnd) {
- hash_ret ^= (*p) * PRIME<64>(5);
- hash_ret = bit_ops::rotl<64>(hash_ret, 11) * PRIME<64>(1);
- p++;
- }
-
- hash_ret ^= hash_ret >> 33;
- hash_ret *= PRIME<64>(2);
- hash_ret ^= hash_ret >> 29;
- hash_ret *= PRIME<64>(3);
- hash_ret ^= hash_ret >> 32;
-
- return hash_ret;
-}
-
-template <size_t N>
-inline hash_t<N> endian_align(const void* input, size_t len, hash_t<N> seed, xxh::endianness endian,
- xxh::alignment align)
-{
- static_assert(!(N != 32 && N != 64), "You can only call endian_align in 32 or 64 bit mode.");
-
- const uint8_t* p = static_cast<const uint8_t*>(input);
- const uint8_t* bEnd = p + len;
- hash_t<N> hash_ret;
-
- if (len >= (N / 2)) {
- const uint8_t* const limit = bEnd - (N / 2);
- hash_t<N> v1 = seed + PRIME<N>(1) + PRIME<N>(2);
- hash_t<N> v2 = seed + PRIME<N>(2);
- hash_t<N> v3 = seed + 0;
- hash_t<N> v4 = seed - PRIME<N>(1);
-
- do {
- v1 = round<N>(v1, mem_ops::readLE_align<N>(p, endian, align));
- p += (N / 8);
- v2 = round<N>(v2, mem_ops::readLE_align<N>(p, endian, align));
- p += (N / 8);
- v3 = round<N>(v3, mem_ops::readLE_align<N>(p, endian, align));
- p += (N / 8);
- v4 = round<N>(v4, mem_ops::readLE_align<N>(p, endian, align));
- p += (N / 8);
- } while (p <= limit);
-
- hash_ret = bit_ops::rotl<N>(v1, 1) + bit_ops::rotl<N>(v2, 7) + bit_ops::rotl<N>(v3, 12) + bit_ops::rotl<N>(v4, 18);
-
- endian_align_sub_mergeround<N>(hash_ret, v1, v2, v3, v4);
- } else {
- hash_ret = seed + PRIME<N>(5);
- }
-
- hash_ret += static_cast<hash_t<N>>(len);
-
- return endian_align_sub_ending<N>(hash_ret, p, bEnd, endian, align);
-}
-} // namespace detail
-
-template <size_t N>
-hash_t<N> xxhash(const void* input, size_t len, hash_t<N> seed = 0, endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- return detail::endian_align<N>(input, len, seed, mem_ops::get_endian(endian), mem_ops::get_alignment<N>(input));
-}
-
-template <size_t N, typename T>
-hash_t<N> xxhash(const std::basic_string<T>& input, hash_t<N> seed = 0, endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- return detail::endian_align<N>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed,
- mem_ops::get_endian(endian),
- mem_ops::get_alignment<N>(static_cast<const void*>(input.data())));
-}
-
-template <size_t N, typename ContiguousIterator>
-hash_t<N> xxhash(ContiguousIterator begin, ContiguousIterator end, hash_t<N> seed = 0,
- endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- using T = typename std::decay_t<decltype(*end)>;
- return detail::endian_align<N>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed,
- mem_ops::get_endian(endian),
- mem_ops::get_alignment<N>(static_cast<const void*>(&*begin)));
-}
-
-template <size_t N, typename T>
-hash_t<N> xxhash(const std::vector<T>& input, hash_t<N> seed = 0, endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- return detail::endian_align<N>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed,
- mem_ops::get_endian(endian),
- mem_ops::get_alignment<N>(static_cast<const void*>(input.data())));
-}
-
-template <size_t N, typename T, size_t AN>
-hash_t<N> xxhash(const std::array<T, AN>& input, hash_t<N> seed = 0, endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- return detail::endian_align<N>(static_cast<const void*>(input.data()), AN * sizeof(T), seed,
- mem_ops::get_endian(endian),
- mem_ops::get_alignment<N>(static_cast<const void*>(input.data())));
-}
-
-template <size_t N, typename T>
-hash_t<N> xxhash(const std::initializer_list<T>& input, hash_t<N> seed = 0, endianness endian = endianness::unspecified)
-{
- static_assert(!(N != 32 && N != 64), "You can only call xxhash in 32 or 64 bit mode.");
- return detail::endian_align<N>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed,
- mem_ops::get_endian(endian),
- mem_ops::get_alignment<N>(static_cast<const void*>(input.begin())));
-}
-
-/* *******************************************************************
- * Hash streaming
- *********************************************************************/
-enum class error_code : uint8_t { ok = 0, error };
-
-template <size_t N> class hash_state_t {
- uint64_t total_len = 0;
- hash_t<N> v1 = 0, v2 = 0, v3 = 0, v4 = 0;
- std::array<hash_t<N>, 4> mem = {{0, 0, 0, 0}};
- uint32_t memsize = 0;
-
- inline error_code _update_impl(const void* input, size_t length, endianness endian)
- {
- const uint8_t* p = reinterpret_cast<const uint8_t*>(input);
- const uint8_t* const bEnd = p + length;
-
- if (!input) {
- return xxh::error_code::error;
- }
-
- total_len += length;
-
- if (memsize + length < (N / 2)) { /* fill in tmp buffer */
- memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, length);
- memsize += static_cast<uint32_t>(length);
- return error_code::ok;
- }
-
- if (memsize) { /* some data left from previous update */
- memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, (N / 2) - memsize);
-
- const hash_t<N>* ptr = mem.data();
- v1 = detail::round<N>(v1, mem_ops::readLE<N>(ptr, endian));
- ptr++;
- v2 = detail::round<N>(v2, mem_ops::readLE<N>(ptr, endian));
- ptr++;
- v3 = detail::round<N>(v3, mem_ops::readLE<N>(ptr, endian));
- ptr++;
- v4 = detail::round<N>(v4, mem_ops::readLE<N>(ptr, endian));
-
- p += (N / 2) - memsize;
- memsize = 0;
- }
-
- if (p <= bEnd - (N / 2)) {
- const uint8_t* const limit = bEnd - (N / 2);
-
- do {
- v1 = detail::round<N>(v1, mem_ops::readLE<N>(p, endian));
- p += (N / 8);
- v2 = detail::round<N>(v2, mem_ops::readLE<N>(p, endian));
- p += (N / 8);
- v3 = detail::round<N>(v3, mem_ops::readLE<N>(p, endian));
- p += (N / 8);
- v4 = detail::round<N>(v4, mem_ops::readLE<N>(p, endian));
- p += (N / 8);
- } while (p <= limit);
- }
-
- if (p < bEnd) {
- memcpy(mem.data(), p, static_cast<size_t>(bEnd - p));
- memsize = static_cast<uint32_t>(bEnd - p);
- }
-
- return error_code::ok;
- }
-
- inline hash_t<N> _digest_impl(endianness endian) const
- {
- const uint8_t* p = reinterpret_cast<const uint8_t*>(mem.data());
- const uint8_t* const bEnd = reinterpret_cast<const uint8_t*>(mem.data()) + memsize;
- hash_t<N> hash_ret;
-
- if (total_len > (N / 2)) {
- hash_ret =
- bit_ops::rotl<N>(v1, 1) + bit_ops::rotl<N>(v2, 7) + bit_ops::rotl<N>(v3, 12) + bit_ops::rotl<N>(v4, 18);
-
- detail::endian_align_sub_mergeround<N>(hash_ret, v1, v2, v3, v4);
- } else {
- hash_ret = v3 + detail::PRIME<N>(5);
- }
-
- hash_ret += static_cast<hash_t<N>>(total_len);
-
- return detail::endian_align_sub_ending<N>(hash_ret, p, bEnd, endian, alignment::unaligned);
- }
-
-public:
- hash_state_t(hash_t<N> seed = 0)
- {
- static_assert(!(N != 32 && N != 64), "You can only stream hashing in 32 or 64 bit mode.");
- v1 = seed + detail::PRIME<N>(1) + detail::PRIME<N>(2);
- v2 = seed + detail::PRIME<N>(2);
- v3 = seed + 0;
- v4 = seed - detail::PRIME<N>(1);
- };
-
- hash_state_t operator=(hash_state_t<N>& other) { memcpy(this, other, sizeof(hash_state_t<N>)); }
-
- error_code reset(hash_t<N> seed = 0)
- {
- memset(this, 0, sizeof(hash_state_t<N>));
- v1 = seed + detail::PRIME<N>(1) + detail::PRIME<N>(2);
- v2 = seed + detail::PRIME<N>(2);
- v3 = seed + 0;
- v4 = seed - detail::PRIME<N>(1);
- return error_code::ok;
- }
-
- error_code update(const void* input, size_t length, endianness endian = endianness::unspecified)
- {
- return _update_impl(input, length, mem_ops::get_endian(endian));
- }
-
- template <typename T>
- error_code update(const std::basic_string<T>& input, endianness endian = endianness::unspecified)
- {
- return _update_impl(static_cast<const void*>(input.data()), input.length() * sizeof(T),
- mem_ops::get_endian(endian));
- }
-
- template <typename ContiguousIterator>
- error_code update(ContiguousIterator begin, ContiguousIterator end, endianness endian = endianness::unspecified)
- {
- using T = typename std::decay_t<decltype(*end)>;
- return _update_impl(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), mem_ops::get_endian(endian));
- }
-
- template <typename T> error_code update(const std::vector<T>& input, endianness endian = endianness::unspecified)
- {
- return _update_impl(static_cast<const void*>(input.data()), input.size() * sizeof(T), mem_ops::get_endian(endian));
- }
-
- template <typename T, size_t AN>
- error_code update(const std::array<T, AN>& input, endianness endian = endianness::unspecified)
- {
- return _update_impl(static_cast<const void*>(input.data()), AN * sizeof(T), mem_ops::get_endian(endian));
- }
-
- template <typename T>
- error_code update(const std::initializer_list<T>& input, endianness endian = endianness::unspecified)
- {
- return _update_impl(static_cast<const void*>(input.begin()), input.size() * sizeof(T), mem_ops::get_endian(endian));
- }
-
- hash_t<N> digest(endianness endian = endianness::unspecified) { return _digest_impl(mem_ops::get_endian(endian)); }
-};
-
-using hash_state32_t = hash_state_t<32>;
-using hash_state64_t = hash_state_t<64>;
-
-/* *******************************************************************
- * Canonical
- *********************************************************************/
-
-template <size_t N> struct canonical_t {
- std::array<uint8_t, N / 8> digest;
-
- canonical_t(hash_t<N> hash)
- {
- if (mem_ops::is_little_endian()) {
- hash = bit_ops::swap<N>(hash);
- }
- memcpy(digest.data(), &hash, sizeof(canonical_t<N>));
- }
-
- hash_t<N> get_hash() const { return mem_ops::readBE<N>(&digest); }
-};
-
-using canonical32_t = canonical_t<32>;
-using canonical64_t = canonical_t<64>;
-} // namespace xxh
