IoHash.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "HAL/Platform.h"
#include "HAL/PlatformString.h"
#include "HAL/UnrealMemory.h"
#include "Hash/Blake3.h"
#include "Memory/MemoryFwd.h"
#include "Memory/MemoryView.h"
#include "Misc/AssertionMacros.h"
#include "Serialization/Archive.h"
#include "String/BytesToHex.h"
#include "String/HexToBytes.h"
 
class FCompositeBuffer;
template <typename CharType> class TStringBuilderBase;
 
struct FIoHash
{
public:
    using ByteArray = uint8[20];
 
    constexpr FIoHash() = default;
 
    inline explicit FIoHash(const ByteArray& Hash);
 
    inline FIoHash(const FBlake3Hash& Hash);
 
    inline explicit FIoHash(FAnsiStringView HexHash);
    inline explicit FIoHash(FWideStringView HexHash);
    inline explicit FIoHash(FUtf8StringView HexHash);
 
    inline static FIoHash FromView(FMemoryView Hash);
 
    inline void Reset() { *this = FIoHash(); }
 
    inline bool IsZero() const;
 
    inline ByteArray& GetBytes() { return Hash; }
    inline const ByteArray& GetBytes() const { return Hash; }
 
    [[nodiscard]] static inline FIoHash HashBuffer(FMemoryView View);
    [[nodiscard]] static inline FIoHash HashBuffer(const void* Data, uint64 Size);
    [[nodiscard]] static inline FIoHash HashBuffer(const FCompositeBuffer& Buffer);
 
    static const FIoHash Zero;
 
private:
    alignas(uint32) ByteArray Hash{};
 
    friend inline bool operator==(const FIoHash& A, const FIoHash& B)
    {
        return FMemory::Memcmp(A.GetBytes(), B.GetBytes(), sizeof(decltype(A.GetBytes()))) == 0;
    }
 
    friend inline bool operator!=(const FIoHash& A, const FIoHash& B)
    {
        return FMemory::Memcmp(A.GetBytes(), B.GetBytes(), sizeof(decltype(A.GetBytes()))) != 0;
    }
 
    friend inline bool operator<(const FIoHash& A, const FIoHash& B)
    {
        return FMemory::Memcmp(A.GetBytes(), B.GetBytes(), sizeof(decltype(A.GetBytes()))) < 0;
    }
 
    friend inline uint32 GetTypeHash(const FIoHash& Value)
    {
        return *reinterpret_cast<const uint32*>(Value.GetBytes());
    }
 
    friend inline FArchive& operator<<(FArchive& Ar, FIoHash& InHash)
    {
        Ar.Serialize(InHash.GetBytes(), sizeof(decltype(InHash.GetBytes())));
        return Ar;
    }
};
 
inline const FIoHash FIoHash::Zero;
 
inline FIoHash::FIoHash(const ByteArray& InHash)
{
    FMemory::Memcpy(Hash, InHash, sizeof(ByteArray));
}
 
inline FIoHash::FIoHash(const FBlake3Hash& InHash)
{
    static_assert(sizeof(ByteArray) <= sizeof(decltype(InHash.GetBytes())), "Reading too many bytes from source.");
    FMemory::Memcpy(Hash, InHash.GetBytes(), sizeof(ByteArray));
}
 
inline FIoHash::FIoHash(const FAnsiStringView HexHash)
{
    check(HexHash.Len() == sizeof(ByteArray) * 2);
    UE::String::HexToBytes(HexHash, Hash);
}
 
inline FIoHash::FIoHash(const FWideStringView HexHash)
{
    check(HexHash.Len() == sizeof(ByteArray) * 2);
    UE::String::HexToBytes(HexHash, Hash);
}
 
inline FIoHash::FIoHash(const FUtf8StringView HexHash)
{
    check(HexHash.Len() == sizeof(ByteArray) * 2);
    UE::String::HexToBytes(HexHash, Hash);
}
 
inline FIoHash FIoHash::FromView(const FMemoryView InHash)
{
    checkf(InHash.GetSize() == sizeof(ByteArray),
        TEXT("FIoHash cannot be constructed from a view of %" UINT64_FMT " bytes."), InHash.GetSize());
    FIoHash NewHash;
    FMemory::Memcpy(NewHash.Hash, InHash.GetData(), sizeof(ByteArray));
    return NewHash;
}
 
inline bool FIoHash::IsZero() const
{
    using UInt32Array = uint32[5];
    static_assert(sizeof(UInt32Array) == sizeof(ByteArray), "Invalid size for UInt32Array");
    for (uint32 Value : reinterpret_cast<const UInt32Array&>(Hash))
    {
        if (Value != 0)
        {
            return false;
        }
    }
    return true;
}
 
inline FIoHash FIoHash::HashBuffer(FMemoryView View)
{
    return FBlake3::HashBuffer(View);
}
 
inline FIoHash FIoHash::HashBuffer(const void* Data, uint64 Size)
{
    return FBlake3::HashBuffer(Data, Size);
}
 
inline FIoHash FIoHash::HashBuffer(const FCompositeBuffer& Buffer)
{
    return FBlake3::HashBuffer(Buffer);
}
 
template <typename CharType>
inline TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const FIoHash& Hash)
{
    UE::String::BytesToHexLower(Hash.GetBytes(), Builder);
    return Builder;
}
 
inline void LexFromString(FIoHash& OutHash, const TCHAR* Buffer)
{
    OutHash = FIoHash(Buffer);
}
 
[[nodiscard]] CORE_API FString LexToString(const FIoHash& Hash);
 
 
class FIoHashBuilder : public FBlake3
{
public:
    [[nodiscard]] inline FIoHash Finalize() const { return FBlake3::Finalize(); }
 
    [[nodiscard]] inline static FIoHash HashBuffer(FMemoryView View) { return FBlake3::HashBuffer(View); }
    [[nodiscard]] inline static FIoHash HashBuffer(const void* Data, uint64 Size) { return FBlake3::HashBuffer(Data, Size); }
    [[nodiscard]] inline static FIoHash HashBuffer(const FCompositeBuffer& Buffer) { return FBlake3::HashBuffer(Buffer); }
};