HashCodeUtil.h

Go to the documentation of this file.

#ifndef ZSERIO_HASH_CODE_UTIL_H_INC
#define ZSERIO_HASH_CODE_UTIL_H_INC
 
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
 
#include "zserio/Bytes.h"
#include "zserio/FloatUtil.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
#include "zserio/Vector.h"
 
namespace zserio
{
 
static const uint32_t HASH_PRIME_NUMBER = 37;
static const uint32_t HASH_SEED = 23;
 
inline uint32_t calcHashCodeFirstTerm(uint32_t seedValue)
{
    return HASH_PRIME_NUMBER * seedValue;
}
 
template <typename T>
inline typename std::enable_if<std::is_integral<T>::value && (sizeof(T) <= 4), uint32_t>::type calcHashCode(
        uint32_t seedValue, T value)
{
    return calcHashCodeFirstTerm(seedValue) + static_cast<uint32_t>(value);
}
 
template <typename T>
inline typename std::enable_if<std::is_integral<T>::value && (sizeof(T) > 4), uint32_t>::type calcHashCode(
        uint32_t seedValue, T value)
{
    const auto unsignedValue = static_cast<typename std::make_unsigned<T>::type>(value);
    return calcHashCodeFirstTerm(seedValue) + static_cast<uint32_t>(unsignedValue ^ (unsignedValue >> 32U));
}
 
inline uint32_t calcHashCode(uint32_t seedValue, float value)
{
    return calcHashCode(seedValue, convertFloatToUInt32(value));
}
 
inline uint32_t calcHashCode(uint32_t seedValue, double value)
{
    return calcHashCode(seedValue, convertDoubleToUInt64(value));
}
 
inline uint32_t calcHashCode(uint32_t seedValue, Bool value)
{
    return calcHashCode(seedValue, static_cast<Bool::ValueType>(value));
}
 
template <BitSize BIT_SIZE, bool IS_SIGNED>
inline uint32_t calcHashCode(uint32_t seedValue, detail::FixedIntWrapper<BIT_SIZE, IS_SIGNED> value)
{
    using ValueType = typename detail::FixedIntWrapper<BIT_SIZE, IS_SIGNED>::ValueType;
    return calcHashCode(seedValue, static_cast<ValueType>(value));
}
 
template <typename VALUE_TYPE>
inline uint32_t calcHashCode(uint32_t seedValue, detail::DynIntWrapper<VALUE_TYPE> value)
{
    return calcHashCode(seedValue, static_cast<VALUE_TYPE>(value));
}
 
template <typename VALUE_TYPE, detail::VarIntType VAR_TYPE>
inline uint32_t calcHashCode(uint32_t seedValue, detail::VarIntWrapper<VALUE_TYPE, VAR_TYPE> value)
{
    return calcHashCode(seedValue, static_cast<VALUE_TYPE>(value));
}
 
template <typename VALUE_TYPE, detail::FloatType FLOAT_TYPE>
inline uint32_t calcHashCode(uint32_t seedValue, detail::FloatWrapper<VALUE_TYPE, FLOAT_TYPE> value)
{
    return calcHashCode(seedValue, static_cast<VALUE_TYPE>(value));
}
 
// TODO[Mi-L@]: support all zserio wrappers
 
template <typename ALLOC>
inline uint32_t calcHashCode(uint32_t seedValue, const BasicString<ALLOC>& stringValue)
{
    uint32_t result = seedValue;
    for (auto element : stringValue)
    {
        result = calcHashCode(result, element);
    }
 
    return result;
}
 
inline uint32_t calcHashCode(uint32_t seedValue, std::string_view stringValue)
{
    uint32_t result = seedValue;
    for (auto element : stringValue)
    {
        result = calcHashCode(result, element);
    }
 
    return result;
}
 
template <typename T>
inline std::enable_if_t<std::is_enum_v<T> || is_bitmask_v<T>, uint32_t> calcHashCode(
        uint32_t seedValue, T value)
{
    return calcHashCode(seedValue, std::hash<T>()(value));
}
 
template <typename OBJECT>
inline std::enable_if_t<!std::is_enum_v<OBJECT> && !is_bitmask_v<OBJECT> && !std::is_integral_v<OBJECT>,
        uint32_t>
calcHashCode(uint32_t seedValue, const OBJECT& object)
{
    return calcHashCode(seedValue, std::hash<OBJECT>()(object));
}
 
// TODO[Mi-L@]: implement for a generic span?
inline uint32_t calcHashCode(uint32_t seedValue, const BytesView& bytes)
{
    uint32_t result = seedValue;
    for (auto byte : bytes)
    {
        result = calcHashCode(result, byte);
    }
 
    return result;
}
 
template <typename ARRAY_ELEMENT, typename ALLOC>
inline uint32_t calcHashCode(uint32_t seedValue, const Vector<ARRAY_ELEMENT, ALLOC>& array)
{
    uint32_t result = seedValue;
    for (const ARRAY_ELEMENT& element : array)
    {
        result = calcHashCode(result, element);
    }
 
    return result;
}
 
inline uint32_t calcHashCode(uint32_t seedValue, std::monostate)
{
    return calcHashCode(seedValue, 1729);
}
 
} // namespace zserio
 
#endif // ZSERIO_HASH_CODE_UTIL_H_INC