Hash.impl.h

// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
//-----------------------------------------------------------------------------
// MurmurHash3 was written by Austin Appleby, and is placed in the public
// domain. The author hereby disclaims copyright to this source code.
// Code from https://github.com/aappleby/smhasher
 
namespace AtomsCore
{
//-----------------------------------------------------------------------------
// Platform-specific functions and macros
// Microsoft Visual Studio
#if defined(_MSC_VER)
#define FORCE_INLINE    __forceinline
#include <stdlib.h>
#define ROTL32(x,y) _rotl(x,y)
#define ROTL64(x,y) _rotl64(x,y)
#define BIG_CONSTANT(x) (x)
// Other compilers
#else   // defined(_MSC_VER)
#define FORCE_INLINE inline __attribute__((always_inline))
 
    inline uint32_t rotl32(uint32_t x, int8_t r)
    {
        return (x << r) | (x >> (32 - r));
    }
 
    inline uint64_t rotl64(uint64_t x, int8_t r)
    {
        return (x << r) | (x >> (64 - r));
    }
 
#define ROTL32(x,y) rotl32(x,y)
#define ROTL64(x,y) rotl64(x,y)
 
#define BIG_CONSTANT(x) (x##LLU)
#endif // !defined(_MSC_VER)
 
    //-----------------------------------------------------------------------------
    // Block read - if your platform needs to do endian-swapping or can only
    // handle aligned reads, do the conversion here
 
 
    FORCE_INLINE uint32_t getblock32(const uint32_t * p, size_t i)
    {
        return p[i];
    }
 
    FORCE_INLINE uint64_t getblock64(const uint64_t * p, size_t i)
    {
        return p[i];
    }
 
    //-----------------------------------------------------------------------------
    // Finalization mix - force all bits of a hash block to avalanche
 
    FORCE_INLINE uint32_t fmix32(uint32_t h)
    {
        h ^= h >> 16;
        h *= 0x85ebca6b;
        h ^= h >> 13;
        h *= 0xc2b2ae35;
        h ^= h >> 16;
        return h;
    }
 
    //----------
    FORCE_INLINE uint64_t fmix64(uint64_t k)
    {
        k ^= k >> 33;
        k *= BIG_CONSTANT(0xff51afd7ed558ccd);
        k ^= k >> 33;
        k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
        k ^= k >> 33;
        return k;
    }
 
 
    const MurmurHash3 &MurmurHash3::operator = (const MurmurHash3 &other)
    {
        seed[0] = other.seed[0];
        seed[1] = other.seed[1];
        return *this;
    }
 
    bool MurmurHash3::operator==(const MurmurHash3 &rh) const
    {
        return seed[0] == rh.seed[0] && seed[1] == rh.seed[1];
    }
 
    bool MurmurHash3::operator!=(const MurmurHash3 &rh) const
    {
        return seed[0] != rh.seed[0] || seed[1] != rh.seed[1];
    }
 
    bool MurmurHash3::operator<(const MurmurHash3 &rh) const
    {
        return seed[0] < rh.seed[0] || (seed[0] == rh.seed[0] && seed[1] < rh.seed[1]);
    }
 
    void MurmurHash3::hash(const void *key, size_t len)
    {
        const uint8_t * data = (const uint8_t*)key;
        const size_t nblocks = len / 16;
 
        uint64_t h1 = seed[0];
        uint64_t h2 = seed[1];
 
        const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
        const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
 
        //----------
        // body
        const uint64_t * blocks = (const uint64_t *)(data);
        
        for (size_t i = 0; i < nblocks; i++)
        {
            uint64_t k1 = getblock64(blocks, i * 2 + 0);
            uint64_t k2 = getblock64(blocks, i * 2 + 1);
            k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
            h1 = ROTL64(h1, 27); h1 += h2; h1 = h1 * 5 + 0x52dce729;
            k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
            h2 = ROTL64(h2, 31); h2 += h1; h2 = h2 * 5 + 0x38495ab5;
        }
 
        //----------
        // tail
 
        const uint8_t * tail = (const uint8_t*)(data + nblocks * 16);
        
        uint64_t k1 = 0;
        uint64_t k2 = 0;
 
        switch (len & 15)
        {
        case 15: k2 ^= ((uint64_t)tail[14]) << 48;
        case 14: k2 ^= ((uint64_t)tail[13]) << 40;
        case 13: k2 ^= ((uint64_t)tail[12]) << 32;
        case 12: k2 ^= ((uint64_t)tail[11]) << 24;
        case 11: k2 ^= ((uint64_t)tail[10]) << 16;
        case 10: k2 ^= ((uint64_t)tail[9]) << 8;
        case  9: k2 ^= ((uint64_t)tail[8]) << 0;
            k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
        case  8: k1 ^= ((uint64_t)tail[7]) << 56;
        case  7: k1 ^= ((uint64_t)tail[6]) << 48;
        case  6: k1 ^= ((uint64_t)tail[5]) << 40;
        case  5: k1 ^= ((uint64_t)tail[4]) << 32;
        case  4: k1 ^= ((uint64_t)tail[3]) << 24;
        case  3: k1 ^= ((uint64_t)tail[2]) << 16;
        case  2: k1 ^= ((uint64_t)tail[1]) << 8;
        case  1: k1 ^= ((uint64_t)tail[0]) << 0;
            k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
        };
        
        //----------
        // finalization
 
        h1 ^= len; h2 ^= len;
        h1 += h2;
        h2 += h1;
 
        h1 = fmix64(h1);
        h2 = fmix64(h2);
 
        h1 += h2;
        h2 += h1;
 
        ((uint64_t*)seed)[0] = h1;
        ((uint64_t*)seed)[1] = h2;
    }
 
    void MurmurHash3::append(bool data)
    {
        char value = data;
        hash(&value, sizeof(char));
    }
 
    void MurmurHash3::append(char data)
    {
        hash(&data, sizeof(char));
    }
 
    void MurmurHash3::append(unsigned char data)
    {
        hash(&data, sizeof(unsigned char));
    }
 
    void MurmurHash3::append(short data)
    {
        hash(&data, sizeof(short));
    }
 
    void MurmurHash3::append(unsigned short data)
    {
        hash(&data, sizeof(unsigned short));
    }
 
    void MurmurHash3::append(int data)
    {
        hash(&data, sizeof(int));
    }
 
    void MurmurHash3::append(unsigned int data)
    {
        hash(&data, sizeof(unsigned int));
    }
 
    void MurmurHash3::append(int64_t data)
    {
        hash(&data, sizeof(int64_t));
    }
 
    void MurmurHash3::append(uint64_t data)
    {
        hash(&data, sizeof(uint64_t));
    }
#ifdef __APPLE__
    void MurmurHash3::append(size_t data)
    {
        hash(&data, sizeof(uint64_t));
    }
#endif
    void MurmurHash3::append(float data)
    {
        hash(&data, sizeof(float));
    }
 
    void MurmurHash3::append(double data)
    {
        hash(&data, sizeof(double));
    }
 
    void MurmurHash3::append(const char *data)
    {
        hash(&data, sizeof(char) * strlen(data));
    }
 
    void MurmurHash3::append(const std::string &data)
    {
        hash(&data[0], sizeof(char) * data.size());
    }
 
    void MurmurHash3::append(const Vector2 &data)
    {
        hash(&data.getValue()[0], sizeof(double) * 2);
    }
 
    void MurmurHash3::append(const Vector2f &data)
    {
        hash(&data.getValue()[0], sizeof(float) * 2);
    }
 
    void MurmurHash3::append(const Vector2i &data)
    {
        hash(&data.getValue()[0], sizeof(int) * 2);
    }
 
    void MurmurHash3::append(const Vector3 &data)
    {
        hash(&data.getValue()[0], sizeof(double) * 2);
    }
 
    void MurmurHash3::append(const Vector3f &data)
    {
        hash(&data.getValue()[0], sizeof(float) * 3);
    }
 
    void MurmurHash3::append(const Vector3i &data)
    {
        hash(&data.getValue()[0], sizeof(int) * 3);
    }
 
    void MurmurHash3::append(const Vector4 &data)
    {
        append(data.x); append(data.y); append(data.z); append(data.w);
    }
 
    void MurmurHash3::append(const Vector4f &data)
    {
        append(data.x); append(data.y); append(data.z); append(data.w);
    }
 
    void MurmurHash3::append(const Vector4i &data)
    {
        append(data.x); append(data.y); append(data.z); append(data.w);
    }
 
    void MurmurHash3::append(const Euler &data)
    {
        hash(&data.getValue()[0], sizeof(double));
    }
 
    void MurmurHash3::append(const Eulerf &data)
    {
        hash(&data.getValue()[0], sizeof(float));
    }
 
    void MurmurHash3::append(const Quaternion &data)
    {
        append(data.r); append(data.v);
    }
 
    void MurmurHash3::append(const Quaternionf &data)
    {
        append(data.r); append(data.v);
    }
 
    void MurmurHash3::append(const Box2 &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Box2i &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Box2f &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Box3 &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Box3i &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Box3f &data)
    {
        append(data.min); append(data.max);
    }
 
    void MurmurHash3::append(const Matrix &data)
    {
        hash(&data.getValue()[0], sizeof(double) * 16);
    }
 
    void MurmurHash3::append(const Matrixf &data)
    {
        hash(&data.getValue()[0], sizeof(float) * 16);
    }
 
    // Vectors
 
    void MurmurHash3::append(const std::vector<bool>& data)
    {
        for (size_t i = 0; i < data.size(); ++i)
        {
            append(data[i]);
        }
    }
 
    void MurmurHash3::append(const std::vector<char>& data)
    {
        hash(&data[0], sizeof(char) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<unsigned char>& data)
    {
        hash(&data[0], sizeof(unsigned char) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<short>& data)
    {
        hash(&data[0], sizeof(short) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<unsigned short>& data)
    {
        hash(&data[0], sizeof(unsigned short) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<int>& data)
    {
        hash(&data[0], sizeof(int) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<unsigned int>& data)
    {
        hash(&data[0], sizeof(unsigned int) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<int64_t>& data)
    {
        hash(&data[0], sizeof(int64_t) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<uint64_t>& data)
    {
        hash(&data[0], sizeof(uint64_t) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<float>& data)
    {
        hash(&data[0], sizeof(float) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<double>& data)
    {
        hash(&data[0], sizeof(double) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<std::string> &data)
    {
        for (size_t i = 0; i < data.size(); ++i)
        {
            append(data[i]);
        }
    }
 
    void MurmurHash3::append(const std::vector<Vector2> &data)
    {
        hash(&data[0], sizeof(Vector2) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector2f> &data)
    {
        hash(&data[0], sizeof(Vector2f) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector2i> &data)
    {
        hash(&data[0], sizeof(Vector2i) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector3> &data)
    {
        hash(&data[0], sizeof(Vector3) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector3f> &data)
    {
        hash(&data[0], sizeof(Vector3f) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector3i> &data)
    {
        hash(&data[0], sizeof(Vector3i) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector4> &data)
    {
        hash(&data[0], sizeof(Vector4) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector4f> &data)
    {
        hash(&data[0], sizeof(Vector4f) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Vector4i> &data)
    {
        hash(&data[0], sizeof(Vector4i) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Euler> &data)
    {
        hash(&data[0], sizeof(Euler) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Eulerf> &data)
    {
        hash(&data[0], sizeof(Eulerf) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Quaternion> &data)
    {
        hash(&data[0], sizeof(Quaternion) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Quaternionf> &data)
    {
        hash(&data[0], sizeof(Quaternionf) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box2> &data)
    {
        hash(&data[0], sizeof(Box2) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box2i> &data)
    {
        hash(&data[0], sizeof(Box2i) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box2f> &data)
    {
        hash(&data[0], sizeof(Box2f) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box3> &data)
    {
        hash(&data[0], sizeof(Box3) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box3i> &data)
    {
        hash(&data[0], sizeof(Box3i) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Box3f> &data)
    {
        hash(&data[0], sizeof(Box3f) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Matrix> &data)
    {
        hash(&data[0], sizeof(Matrix) * data.size());
    }
 
    void MurmurHash3::append(const std::vector<Matrixf> &data)
    {
        hash(&data[0], sizeof(Matrixf) * data.size());
    }
 
    void MurmurHash3::append(const MurmurHash3& data)
    {
        hash(&data.seed[0], sizeof(size_t) * 2);
    }
}