hyzboy/CMUtil
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

redefrag codes of Hash

Browse Source
This commit is contained in:
hyzboy 2024-11-26 00:39:53 +08:00
parent 79bb27d9cb
commit 289cf37a6f
16 changed files with 259 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
inc/hgl/util/hash/Hash.h
View File

@ -23,23 +23,24 @@ namespace hgl
xxH32, xxH32,
xxH64, xxH64,
XXH3_64, xxH3_64,
XXH3_128, xxH3_128,
FNV1a, FNV1a,
// Murmur3, Murmur3,
// City64, City32,
// City128, City64,
City128,
ENUM_CLASS_RANGE(Adler32,FNV1a) ENUM_CLASS_RANGE(Adler32,City128)
};//enum HASH };//enum HASH
/** /**
* Hash编码结构模板 * Hash编码结构模板
*/ */
template<int SIZE> struct HashCode template<size_t SIZE> struct HashCode
{ {
unsigned char code[SIZE]; uint8 code[SIZE]{};
public: public:
@ -48,39 +49,15 @@ namespace hgl
public: public:
HashCode() static constexpr int size()noexcept{return SIZE;}
{
hgl_zero(code);
}
static constexpr int size(){return SIZE;} const uint8 operator[](int index)const{return code[index];}
const unsigned char operator[](int index)const void CopyFrom (const void *ptr){memcpy(code,ptr,SIZE);}
{ void FromString (const char *str){ParseHexStr(code,str,SIZE);}
return code[index];
}
void CopyFrom(const void *ptr) template<typename T> void ToUpperString(T *str,const T gap_char=0) const {ToUpperHexStr<T>(str,code,SIZE,gap_char);}
{ template<typename T> void ToLowerString(T *str,const T gap_char=0) const {ToLowerHexStr<T>(str,code,SIZE,gap_char);}
memcpy(code,ptr,SIZE);
}
void FromString(const char *str)
{
ParseHexStr(code,str,SIZE);
}
template<typename T>
void ToUpperString(T *str,const T gap_char=0) const
{
ToUpperHexStr<T>(str,code,SIZE,gap_char);
}
template<typename T>
void ToLowerString(T *str,const T gap_char=0) const
{
ToLowerHexStr<T>(str,code,SIZE,gap_char);
}
const int CompFunc(const HashCode<SIZE> &hash)const const int CompFunc(const HashCode<SIZE> &hash)const
{ {
@ -100,36 +77,23 @@ namespace hgl
} }
CompOperator(const HashCode<SIZE> &,CompFunc) CompOperator(const HashCode<SIZE> &,CompFunc)
};//template<int SIZE> struct HashCode };//template<size_t SIZE> struct HashCode
using HashCodeCRC32 =HashCode<4> ;
using HashCodeAdler32 =HashCode<4> ;
using HashCodeMD5 =HashCode<16> ;
using HashCodeMD4 =HashCode<16> ;
using HashCodeSHA1 =HashCode<20> ;
using HashCodeSHA1LE =HashCode<20> ;
using HashCodeSHA256 =HashCode<32> ;
using HashCodeSHA512 =HashCode<64> ;
using HashCodexxH32 =HashCode<4> ;
using HashCodexxH64 =HashCode<8> ;
using HashCodeXXH3_64 =HashCode<8> ;
using HashCodeXXH3_128 =HashCode<16> ;
using HashCodeFNV1a =HashCode<4>;
const int hash_code_bytes[]={4,4,16,16,20,20,32,64,4,8,16,4}; //hash码长度
/** /**
* 散列值计算功能基类 * 散列值计算功能基类
*/ */
class Hash ///散列值计算功能基类 class Hash ///散列值计算功能基类
{ {
AnsiString hash_name;
size_t hash_size;
public: public:
Hash(const size_t s,const AnsiString &n):hash_size(s),hash_name(n){}
virtual ~Hash()=default; virtual ~Hash()=default;
virtual void GetName(UTF8String &)const=0; ///<取得HASH算法的名称 void GetName (AnsiString &name)const {name=hash_name;} ///<取得HASH算法的名称
virtual void GetName(UTF16String &)const=0; ///<取得HASH算法的名称 const size_t GetHashBytes()const noexcept {return hash_size;} ///<取得HASH码字节长度(MD4/MD5为16,SHA1为20)
virtual const int GetHashBytes()const=0; ///<取得HASH码字节长度(MD4/MD5为16,SHA1为20)
virtual void Init()=0; ///<初始化散列值计算 virtual void Init()=0; ///<初始化散列值计算
virtual void Update(const void *,uint)=0; ///<提交新的数据 virtual void Update(const void *,uint)=0; ///<提交新的数据
@ -150,50 +114,7 @@ namespace hgl
template<HASH ha> Hash *CreateHash(); ///<创建一个hash值计算类实例 template<HASH ha> Hash *CreateHash(); ///<创建一个hash值计算类实例
#define HGL_CREATE_HASH_FUNC(name) Hash *Create##name##Hash(); \ Hash *CreateHash(const HASH ha); ///<创建一个hash值计算类实例
template<> inline Hash *CreateHash<HASH::name>(){return Create##name##Hash();}
HGL_CREATE_HASH_FUNC(Adler32)
HGL_CREATE_HASH_FUNC(CRC32)
HGL_CREATE_HASH_FUNC(MD4)
HGL_CREATE_HASH_FUNC(MD5)
HGL_CREATE_HASH_FUNC(SHA1)
HGL_CREATE_HASH_FUNC(SHA1LE)
HGL_CREATE_HASH_FUNC(SHA256)
HGL_CREATE_HASH_FUNC(SHA512)
HGL_CREATE_HASH_FUNC(xxH32)
HGL_CREATE_HASH_FUNC(xxH64)
HGL_CREATE_HASH_FUNC(XXH3_64)
HGL_CREATE_HASH_FUNC(XXH3_128)
HGL_CREATE_HASH_FUNC(FNV1a)
//#undef HGL_CREATE_HASH_FUNC
inline Hash *CreateHash(HASH ha)
{
RANGE_CHECK_RETURN_NULLPTR(ha)
using CreateHashFunc=Hash *(*)();
const CreateHashFunc func[(size_t)HASH::RANGE_SIZE]=
{
CreateAdler32Hash,
CreateCRC32Hash,
CreateMD4Hash,
CreateMD5Hash,
CreateSHA1Hash,
CreateSHA1LEHash,
CreateSHA256Hash,
CreateSHA512Hash,
CreatexxH32Hash,
CreatexxH64Hash,
CreateXXH3_64Hash,
CreateXXH3_128Hash,
CreateFNV1aHash
};
return func[(size_t)ha]();
}
/** /**
* 计算一段数据的Hash值 * 计算一段数据的Hash值
@ -220,141 +141,29 @@ namespace hgl
} }
/** /**
* 计算一段数据的Hash值 * 取得一个文件的hash值
* @param data 数据指针 * @param filename 文件名
* @param size 数据长度 * @param ha hash对象
* @param ha hash算法 * @param hash_code 计算后的hash存放处
* @param hash_code 计算后的hash值存放处
* @return 是否计算成功 * @return 是否计算成功
*/ */
inline bool CountHash(const void *data,int size,HASH ha,void *hash_code) bool GetFileHash(const OSString &filename,Hash *ha,void *hash_code);
template<typename ha> bool GetFileHash(const OSString &filename,void *hash_code,size_t &hash_size)
{ {
RANGE_CHECK_RETURN_FALSE(ha)
if(!data||size<=0||!hash_code)return(false);
using CountHashFunc=bool (*)(const void *,int size,void *);
const CountHashFunc func[(size_t)HASH::RANGE_SIZE]=
{
CountHash<HASH::Adler32 >,
CountHash<HASH::CRC32 >,
CountHash<HASH::MD4 >,
CountHash<HASH::MD5 >,
CountHash<HASH::SHA1 >,
CountHash<HASH::SHA1LE >,
CountHash<HASH::SHA256 >,
CountHash<HASH::SHA512 >,
CountHash<HASH::xxH32 >,
CountHash<HASH::xxH64 >,
CountHash<HASH::XXH3_64 >,
CountHash<HASH::XXH3_128>,
CountHash<HASH::FNV1a >
};
return func[(size_t)ha](data,size,hash_code);
}
/**
* 计算一段数据的Hash值
* @param data 数据指针
* @param size 数据长度
* @param ha hash算法
* @param hash_str 计算后的hash值存放处
* @param litter 小写字母
* @return 是否计算成功
*/
template<HASH ha> bool CountHashStr(const void *data,int size,UTF8String &hash_str,bool litter=true)
{
if(!data||size<=0)return(false);
Hash *h=CreateHash<ha>(); Hash *h=CreateHash<ha>();
if(!h)return(false); if(!h)return(false);
const int hash_bytes=hash_code_bytes[(size_t)ha]; if(!GetFileHash(filename,h,hash_code))
{
uint8 *hash_code=new uint8[hash_bytes]; delete h;
u8char *hash_code_str=new u8char[1+(hash_bytes<<1)]; return(false);
}
h->Init(); hash_size=h->GetHashBytes();
h->Update(data,size);
h->Final(hash_code);
delete h; delete h;
DataToHexStr(hash_code_str,hash_code,hash_bytes,litter?LowerHexChar:UpperHexChar);
hash_str.SetInstance(hash_code_str,hash_bytes<<1);
delete[] hash_code;
return(true); return(true);
} }
/**
* 计算一段数据的Hash值
* @param data 数据指针
* @param size 数据长度
* @param ha hash算法
* @param hash_str 计算后的hash值存放处
* @param litter 小写字母
* @return 是否计算成功
*/
inline bool CountHash(const void *data,int size,HASH ha,UTF8String &hash_str,bool litter=true)
{
RANGE_CHECK_RETURN_FALSE(ha)
if(!data||size<=0)return(false);
using CountHashFunc=bool (*)(const void *,int size,UTF8String &,bool);
const CountHashFunc func[(size_t)HASH::RANGE_SIZE]=
{
CountHashStr<HASH::Adler32 >,
CountHashStr<HASH::CRC32 >,
CountHashStr<HASH::MD4 >,
CountHashStr<HASH::MD5 >,
CountHashStr<HASH::SHA1 >,
CountHashStr<HASH::SHA1LE >,
CountHashStr<HASH::SHA256 >,
CountHashStr<HASH::SHA512 >,
CountHashStr<HASH::xxH32 >,
CountHashStr<HASH::xxH64 >,
CountHashStr<HASH::XXH3_64 >,
CountHashStr<HASH::XXH3_128 >,
CountHashStr<HASH::FNV1a >
};
return func[(size_t)ha](data,size,hash_str,litter);
}
#define HGL_COUNT_HASH_FUNC(name) inline bool Count##name(const void *data, int size, HashCode##name &hc) { return CountHash<HASH::name>(data, size, &hc); } \
inline bool Count##name(const void *data, int size, UTF8String &hash_str, bool litter = true) { return CountHashStr<HASH::name>(data, size, hash_str, litter); } \
inline bool Count##name(const UTF8String &str, UTF8String &hash_str, bool litter = true) { return CountHashStr<HASH::name>(str.c_str(), str.Length(), hash_str, litter); }
HGL_COUNT_HASH_FUNC(Adler32)
HGL_COUNT_HASH_FUNC(CRC32)
HGL_COUNT_HASH_FUNC(MD4)
HGL_COUNT_HASH_FUNC(MD5)
HGL_COUNT_HASH_FUNC(SHA1)
HGL_COUNT_HASH_FUNC(SHA1LE)
HGL_COUNT_HASH_FUNC(SHA256)
HGL_COUNT_HASH_FUNC(SHA512)
HGL_COUNT_HASH_FUNC(xxH32)
HGL_COUNT_HASH_FUNC(xxH64)
HGL_COUNT_HASH_FUNC(XXH3_64)
HGL_COUNT_HASH_FUNC(XXH3_128)
HGL_COUNT_HASH_FUNC(FNV1a)
#undef HGL_COUNT_HASH_FUNC
/**
* 取得一个文件的hash值
* @param filename 文件名
* @param ha hash算法
* @param hash_code 计算后的hash存放处
* @return 是否计算成功
*/
bool GetFileHash(const OSString &filename,HASH ha,void *hash_code);
/** /**
* 取得一个文件的hash值 * 取得一个文件的hash值
* @param filename 文件名 * @param filename 文件名
@ -363,7 +172,7 @@ namespace hgl
* @param litter 小写字母 * @param litter 小写字母
* @return 是否计算成功 * @return 是否计算成功
*/ */
bool GetFileHash(const OSString &filename,HASH ha,UTF8String &hash_str,bool litter=true); //bool GetFileHash(const OSString &filename,HASH ha,UTF8String &hash_str,bool litter=true);
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl
#endif//HGL_UTIL_HASH_INCLUDE #endif//HGL_UTIL_HASH_INCLUDE

7
inc/hgl/util/hash/SHA1LE.h
View File

@ -36,11 +36,8 @@ namespace hgl
void sha1_transform(); void sha1_transform();
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("SHA1LE");} SHA1LE():Hash(20,"SHA1LE"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("SHA1LE");}
const int GetHashBytes()const override {return DIGEST_SIZE;}
void Init(const uint32 *start_digest,const uint32 *mysterious_constants); ///<开始一次新的HASH计算，并指定初始因子和扰乱因子 void Init(const uint32 *start_digest,const uint32 *mysterious_constants); ///<开始一次新的HASH计算，并指定初始因子和扰乱因子
void Init()override; ///<开始一次新的HASH计算，并使用缺省初始因子和扰乱因子 void Init()override; ///<开始一次新的HASH计算，并使用缺省初始因子和扰乱因子

3
src/CMakeLists.txt
View File

@ -131,6 +131,9 @@ add_cm_library(CMUtil "CM" ${CMD_SOURCE}
${CRYPT_SOURCE_FILES} ${CRYPT_SOURCE_FILES}
) )
find_package(cityhash CONFIG REQUIRED)
target_link_libraries(CMUtil PRIVATE cityhash)
if(CM_UTIL_SUPPORT_XML) if(CM_UTIL_SUPPORT_XML)
target_link_libraries(CMUtil PRIVATE expat::expat) target_link_libraries(CMUtil PRIVATE expat::expat)
endif() endif()

7
src/hash/FNV1a.cpp
View File

@ -29,9 +29,8 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("FNV1a");} FNV1a():Hash(4,"FNV1a"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("FNV1a");}
const int GetHashBytes()const override{return 4;}
void Init()override void Init()override
{ {
result=2166136261u; result=2166136261u;
@ -46,7 +45,7 @@ namespace hgl
} }
};//class FNV1a };//class FNV1a
Hash *CreateFNV1aHash() template<> Hash *CreateHash<HASH::FNV1a>()
{ {
return(new FNV1a); return(new FNV1a);
} }

91
src/hash/GoogleCityHash.cpp
View File

@ -2,4 +2,95 @@
// vcpkg： cityhash, cityhash[sse] // vcpkg： cityhash, cityhash[sse]
#include<hgl/util/hash/Hash.h>
#include<city.h>
namespace hgl
{
namespace util
{
class GoogleCityHash32:public Hash
{
uint32 result;
public:
GoogleCityHash32():Hash(4,"CityHash32")
{}
void Init()override
{
result=0;
}
void Update(const void *input,uint inputLen)override
{
result=CityHash32((const char *)input,inputLen);
}
void Final(void *digest)override
{
*(uint32 *)digest=result;
}
};
template<> Hash *CreateHash<HASH::City32>()
{
return(new GoogleCityHash32);
}
class GoogleCityHash64:public Hash
{
uint64 result;
public:
GoogleCityHash64():Hash(8,"CityHash64")
{}
void Init()override
{
result=0;
}
void Update(const void *input,uint inputLen)override
{
result=::CityHash64WithSeed((const char *)input,inputLen,result);
}
void Final(void *digest)override
{
*(uint64 *)digest=result;
}
};//class CityHash64:public Hash
template<> Hash *CreateHash<HASH::City64>()
{
return(new GoogleCityHash64);
}
class GoogleCityHash128:public Hash
{
uint128 result;
public:
GoogleCityHash128():Hash(16,"CityHash128")
{}
void Init()override
{
result.first=0;
result.second=0;
}
void Update(const void *input,uint inputLen)override
{
::CityHash128WithSeed((const char *)input,inputLen,result);
}
void Final(void *digest)override
{
((uint64 *)digest)[0]=result.first;
((uint64 *)digest)[1]=result.second;
}
};//class CityHash128:public Hash
template<> Hash *CreateHash<HASH::City128>()
{
return(new GoogleCityHash128);
}
}//namespace util
}//namespace hgl

48
src/hash/Hash.cpp
View File

@ -5,11 +5,54 @@ namespace hgl
{ {
namespace util namespace util
{ {
bool GetFileHash(const OSString &filename,HASH ha,void *hash_code) namespace
{ {
Hash *hash=CreateHash(ha); struct
{
HASH hash;
Hash *(*func)();
}
create_hash_func_list[]=
{
#define HASH_FUNC(name) {HASH::name,CreateHash<HASH::name>},
HASH_FUNC(Adler32)
HASH_FUNC(CRC32)
HASH_FUNC(MD4)
HASH_FUNC(MD5)
HASH_FUNC(SHA1)
HASH_FUNC(SHA1LE)
HASH_FUNC(SHA256)
HASH_FUNC(SHA512)
HASH_FUNC(xxH32)
HASH_FUNC(xxH64)
HASH_FUNC(xxH3_64)
HASH_FUNC(xxH3_128)
HASH_FUNC(FNV1a)
HASH_FUNC(Murmur3)
HASH_FUNC(City32)
HASH_FUNC(City64)
HASH_FUNC(City128)
};
}//namespace
Hash *CreateHash(const HASH ha)
{
RANGE_CHECK_RETURN_NULLPTR(ha)
for(auto &hf:create_hash_func_list)
{
if(hf.hash==ha)
return hf.func();
}
return nullptr;
}
bool GetFileHash(const OSString &filename,Hash *hash,void *hash_code)
{
if(!hash)return(false); if(!hash)return(false);
if(!hash_code)return(false);
io::FileInputStream fp; io::FileInputStream fp;
@ -35,7 +78,6 @@ namespace hgl
hash->Final(hash_code); hash->Final(hash_code);
fp.Close(); fp.Close();
delete hash;
return(true); return(true);
} }

29
src/hash/MurmurHash3.cpp
View File

@ -9,7 +9,7 @@ namespace hgl
//本代码来自Github Copilot //本代码来自Github Copilot
//MurmurHash 是一种高性能的哈希算法，特别适用于哈希表。它具有良好的分布性和较低的碰撞率。 //MurmurHash 是一种高性能的哈希算法，特别适用于哈希表。它具有良好的分布性和较低的碰撞率。
uint32_t MurmurHash3(const void *key, int len, uint32_t seed) uint32_t CountMurmurHash3(const void *key, int len, uint32_t seed)
{ {
const uint8_t *data = (const uint8_t *)key; const uint8_t *data = (const uint8_t *)key;
const int nblocks = len / 4; const int nblocks = len / 4;
@ -61,5 +61,32 @@ namespace hgl
return h1; return h1;
} }
}//namespace }//namespace
class MurmurHash3:public Hash
{
uint32_t result;
public:
MurmurHash3():Hash(4,"MurmurHash3")
{}
void Init()override
{
result=0;
}
void Update(const void *input,uint inputLen)override
{
result=CountMurmurHash3(input,inputLen,result);
}
void Final(void *digest)override
{
*(uint32_t *)digest=result;
}
};//class MurmurHash3
template<> Hash *CreateHash<HASH::Murmur3>()
{
return(new MurmurHash3);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

10
src/hash/adler32.cpp
View File

@ -124,10 +124,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("Adler32");} Adler32():Hash(4,"Adler32"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("Adler32");}
const int GetHashBytes()const override{return 4;}
void Init()override void Init()override
{ {
@ -145,6 +142,9 @@ namespace hgl
} }
};//class Adler32 };//class Adler32
Hash *CreateAdler32Hash(){return(new Adler32);} template<> Hash *CreateHash<HASH::Adler32>()
{
return(new Adler32());
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

10
src/hash/crc32.cpp
View File

@ -72,10 +72,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("CRC32");} CRC32():Hash(4,"CRC32"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("CRC32");}
const int GetHashBytes()const override{return 4;}
void Init()override void Init()override
{ {
@ -93,6 +90,9 @@ namespace hgl
} }
};//class CRC32 };//class CRC32
Hash *CreateCRC32Hash(){return(new CRC32);} template<> Hash *CreateHash<HASH::CRC32>()
{
return(new CRC32);
}
}//namespace util }//namespace util
}//namepace hgl }//namepace hgl

18
src/hash/md4.cpp
View File

@ -135,25 +135,16 @@ namespace hgl
memset(x, 0, sizeof(x)); memset(x, 0, sizeof(x));
} }
}//namespace }//namespace
class MD4:public Hash class MD4:public Hash
{ {
enum
{
BLOCK_SIZE = 64,
DIGEST_SIZE = 16
};
uint32 state[4]; // state (ABCD) uint32 state[4]; // state (ABCD)
uint32 count[2]; // number of bits, modulo 2^64 (lsb first) uint32 count[2]; // number of bits, modulo 2^64 (lsb first)
uchar buffer[64]; // input buffer uchar buffer[64]; // input buffer
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("MD4");} MD4():Hash(16,"MD4"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("MD4");}
const int GetHashBytes()const override{return DIGEST_SIZE;}
void Init()override void Init()override
{ {
@ -222,6 +213,9 @@ namespace hgl
} }
};//class MD4 };//class MD4
Hash *CreateMD4Hash(){return(new MD4);} template<> Hash *CreateHash<HASH::MD4>()
{
return(new MD4);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

16
src/hash/md5.cpp
View File

@ -169,22 +169,13 @@ namespace hgl
class MD5:public Hash class MD5:public Hash
{ {
enum
{
BLOCK_SIZE = 64,
DIGEST_SIZE = 16
};
uint32 state[4]; uint32 state[4];
uint32 count[2]; uint32 count[2];
uchar buffer[64]; uchar buffer[64];
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("MD5");} MD5():Hash(16,"MD5"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("MD5");}
const int GetHashBytes()const override{return DIGEST_SIZE;}
void Init()override void Init()override
{ {
@ -253,6 +244,9 @@ namespace hgl
} }
};//class MD5 };//class MD5
Hash *CreateMD5Hash(){return(new MD5);} template<> Hash *CreateHash<HASH::MD5>()
{
return(new MD5);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

10
src/hash/sha1.cpp
View File

@ -149,10 +149,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("SHA1");} SHA1():Hash(20,"SHA1"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("SHA1");}
const int GetHashBytes()const override{return DIGEST_SIZE;}
void Init()override void Init()override
{ {
@ -245,6 +242,9 @@ namespace hgl
} }
};//class SHA1 };//class SHA1
Hash *CreateSHA1Hash(){return(new SHA1);} template<> Hash *CreateHash<HASH::SHA1>()
{
return(new SHA1);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

5
src/hash/sha1le.cpp
View File

@ -222,6 +222,9 @@ namespace hgl
hash[count] = (uint8) ((digest[count>>2]) >> (8*(3-(count & 0x3)))) & 0xff; hash[count] = (uint8) ((digest[count>>2]) >> (8*(3-(count & 0x3)))) & 0xff;
} }
Hash *CreateSHA1LEHash(){return(new SHA1LE);} template<> Hash *CreateHash<HASH::SHA1LE>()
{
return(new SHA1LE);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

10
src/hash/sha256.cpp
View File

@ -91,10 +91,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("SHA256");} SHA256():Hash(DIGEST_SIZE,"SHA256"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("SHA256");}
const int GetHashBytes()const override{return DIGEST_SIZE;}
void Init()override void Init()override
{ {
@ -192,7 +189,10 @@ namespace hgl
} }
};//class SHA256 };//class SHA256
Hash *CreateSHA256Hash(){return(new SHA256);} template<> Hash *CreateHash<HASH::SHA256>()
{
return(new SHA256);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

10
src/hash/sha512.cpp
View File

@ -163,10 +163,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("SHA512");} SHA512():Hash(DIGEST_SIZE,"SHA512"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("SHA512");}
const int GetHashBytes()const override{return DIGEST_SIZE;}
void Init()override void Init()override
{ {
@ -239,6 +236,9 @@ namespace hgl
} }
};//class SHA512 };//class SHA512
Hash *CreateSHA512Hash(){return(new SHA512);} template<> Hash *CreateHash<HASH::SHA512>()
{
return(new SHA512);
}
}//namespace util }//namespace util
}//namespace hgl }//namespace hgl

30
src/hash/xxHash3.cpp
View File

@ -23,10 +23,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("XXH32");} xxHash32():Hash(4,"xxH32"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("XXH32");}
const int GetHashBytes()const override{return 4;}
void Init()override void Init()override
{ {
@ -47,7 +44,7 @@ namespace hgl
} }
};//class xxHash32 };//class xxHash32
Hash *CreatexxH32Hash() template<> Hash *CreateHash<HASH::xxH32>()
{ {
return(new xxHash32); return(new xxHash32);
} }
@ -59,10 +56,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("XXH64");} xxHash64():Hash(8,"xxH64"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("XXH64");}
const int GetHashBytes()const override{return 8;}
void Init()override void Init()override
{ {
@ -83,7 +77,7 @@ namespace hgl
} }
};//class xxHash64 };//class xxHash64
Hash *CreatexxH64Hash() template<> Hash *CreateHash<HASH::xxH64>()
{ {
return(new xxHash64); return(new xxHash64);
} }
@ -95,10 +89,7 @@ namespace hgl
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("XXH3_64bits");} xxHash3_64():Hash(8,"xxH3_64bits"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("XXH3_64bits");}
const int GetHashBytes()const override{return 8;}
void Init()override void Init()override
{ {
@ -119,7 +110,7 @@ namespace hgl
} }
};//class xxHash3_64 };//class xxHash3_64
Hash *CreateXXH3_64Hash() template<> Hash *CreateHash<HASH::xxH3_64>()
{ {
return(new xxHash3_64); return(new xxHash3_64);
} }
@ -130,11 +121,8 @@ namespace hgl
XXH64_hash_t seed; XXH64_hash_t seed;
public: public:
void GetName(UTF8String &str)const override{str=U8_TEXT("XXH3_128bits");} xxHash3_128():Hash(16,"xxH3_128bits"){}
void GetName(UTF16String &str)const override{str=U16_TEXT("XXH3_128bits");}
const int GetHashBytes()const override{return 16;}
void Init()override void Init()override
{ {
@ -155,7 +143,7 @@ namespace hgl
} }
};//class xxHash3_128 };//class xxHash3_128
Hash *CreateXXH3_128Hash() template<> Hash *CreateHash<HASH::xxH3_128>()
{ {
return(new xxHash3_128); return(new xxHash3_128);
} }