Hash.h

#pragma once
// ===========================================================================
// 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
 
#include <AtomsCore/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <string>
#include <vector>
 
namespace AtomsCore
{
    class ATOMSCORE_EXPORT MurmurHash3
    {
    public:
        MurmurHash3();
        
        MurmurHash3(const MurmurHash3& rh);
 
        inline const MurmurHash3 &operator = (const MurmurHash3 &rh);
 
        inline bool operator==(const MurmurHash3 &rh) const;
 
        inline bool operator!=(const MurmurHash3 &rh) const;
 
        inline bool operator<(const MurmurHash3 &rh) const;
 
        inline void hash(const void *data, size_t bytes);
 
        inline void append(bool data);
 
        inline void append(char data);
 
        inline void append(unsigned char data);
 
        inline void append(short data);
 
        inline void append(unsigned short data);
 
        inline void append(int data);
 
        inline void append(unsigned int data);
 
        inline void append(int64_t data);
 
        inline void append(uint64_t data);
#ifdef __APPLE__
        inline void append(size_t data);
#endif
        inline void append(float data);
 
        inline void append(double data);
 
        inline void append(const char *data);
 
        inline void append(const std::string &data);
 
        inline void append(const Vector2 &data);
 
        inline void append(const Vector2f &data);
 
        inline void append(const Vector2i &data);
 
        inline void append(const Vector3 &data);
 
        inline void append(const Vector3f &data);
 
        inline void append(const Vector3i &data);
 
        inline void append(const Vector4 &data);
 
        inline void append(const Vector4f &data);
 
        inline void append(const Vector4i &data);
 
        inline void append(const Euler &data);
 
        inline void append(const Eulerf &data);
 
        inline void append(const Quaternion &data);
 
        inline void append(const Quaternionf &data);
 
        inline void append(const Box2 &data);
 
        inline void append(const Box2i &data);
 
        inline void append(const Box2f &data);
 
        inline void append(const Box3 &data);
 
        inline void append(const Box3i &data);
 
        inline void append(const Box3f &data);
 
        inline void append(const Matrix &data);
 
        inline void append(const Matrixf &data);
 
        inline void append(const std::vector<bool>& data);
 
        inline void append(const std::vector<char>& data);
 
        inline void append(const std::vector<unsigned char>& data);
 
        inline void append(const std::vector<short>& data);
 
        inline void append(const std::vector<unsigned short>& data);
 
        inline void append(const std::vector<int>& data);
 
        inline void append(const std::vector<unsigned int>& data);
 
        inline void append(const std::vector<int64_t>& data);
 
        inline void append(const std::vector<uint64_t>& data);
 
        inline void append(const std::vector<float>& data);
 
        inline void append(const std::vector<double>& data);
 
        inline void append(const std::vector<std::string>& data);
 
        inline void append(const std::vector<Vector2>& data);
 
        inline void append(const std::vector<Vector2f>& data);
 
        inline void append(const std::vector<Vector2i>& data);
 
        inline void append(const std::vector<Vector3>& data);
 
        inline void append(const std::vector<Vector3f>& data);
 
        inline void append(const std::vector<Vector3i>& data);
 
        inline void append(const std::vector<Vector4>& data);
 
        inline void append(const std::vector<Vector4f>& data);
 
        inline void append(const std::vector<Vector4i>& data);
 
        inline void append(const std::vector<Euler>& data);
 
        inline void append(const std::vector<Eulerf>& data);
 
        inline void append(const std::vector<Quaternion>& data);
 
        inline void append(const std::vector<Quaternionf>& data);
 
        inline void append(const std::vector<Box2>& data);
 
        inline void append(const std::vector<Box2i>& data);
 
        inline void append(const std::vector<Box2f>& data);
 
        inline void append(const std::vector<Box3>& data);
 
        inline void append(const std::vector<Box3i>& data);
 
        inline void append(const std::vector<Box3f>& data);
 
        inline void append(const std::vector<Matrix>& data);
 
        inline void append(const std::vector<Matrixf>& data);
 
        inline void append(const MurmurHash3& data);
 
        std::string string() const;
 
    public:
 
        uint64_t seed[2];
    };
}
 
ATOMSCORE_EXPORT std::ostream &operator << (std::ostream &o, const AtomsCore::MurmurHash3 &hash);
 
#include "Hash.impl.h"