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 <type_traits>
#include <vector>
 
#include "zserio/Enums.h"
#include "zserio/FloatUtil.h"
#include "zserio/OptionalHolder.h"
#include "zserio/Types.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));
}
 
template <typename ALLOC>
inline uint32_t calcHashCode(
        uint32_t seedValue, const std::basic_string<char, std::char_traits<char>, ALLOC>& stringValue)
{
    uint32_t result = seedValue;
    for (auto element : stringValue)
    {
        result = calcHashCode(result, element);
    }
 
    return result;
}
 
template <typename ENUM_TYPE>
inline typename std::enable_if<std::is_enum<ENUM_TYPE>::value, uint32_t>::type calcHashCode(
        uint32_t seedValue, ENUM_TYPE enumValue)
{
    return calcHashCode(seedValue, enumHashCode(enumValue));
}
 
template <typename OBJECT>
inline typename std::enable_if<!std::is_enum<OBJECT>::value && !std::is_integral<OBJECT>::value, uint32_t>::type
calcHashCode(uint32_t seedValue, const OBJECT& object)
{
    return calcHashCode(seedValue, object.hashCode());
}
 
template <typename ARRAY_ELEMENT, typename ALLOC>
inline uint32_t calcHashCode(uint32_t seedValue, const std::vector<ARRAY_ELEMENT, ALLOC>& array)
{
    uint32_t result = seedValue;
    for (const ARRAY_ELEMENT& element : array)
    {
        result = calcHashCode(result, element);
    }
 
    return result;
}
 
// must be last because of the two-phase lookup
// - we can have optional array (OptionalHolder<std::vector<T>>), but we cannot have array of optionals
template <typename FIELD>
inline uint32_t calcHashCode(uint32_t seedValue, const InplaceOptionalHolder<FIELD>& optionalHolder)
{
    if (!optionalHolder)
    {
        return calcHashCode(seedValue, 0);
    }
 
    return calcHashCode(seedValue, *optionalHolder);
}
 
template <typename FIELD, typename ALLOC>
inline uint32_t calcHashCode(uint32_t seedValue, const HeapOptionalHolder<FIELD, ALLOC>& optionalHolder)
{
    if (!optionalHolder)
    {
        return calcHashCode(seedValue, 0);
    }
 
    return calcHashCode(seedValue, *optionalHolder);
}
 
} // namespace zserio
 
#endif // ZSERIO_HASH_CODE_UTIL_H_INC