Guid.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PreprocessorHelpers.h"
#include "Hash/CityHash.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Crc.h"
#include "Serialization/Archive.h"
#include "Serialization/MemoryLayout.h"
#include "Serialization/StructuredArchive.h"
 
class FArchive;
class FMemoryImageWriter;
class FMemoryUnfreezeContent;
class FOutputDevice;
class FPointerTableBase;
class FSHA1;
class UObject;
struct FBlake3Hash;
template <typename CharType> class TStringBuilderBase;
template <typename T> struct TCanBulkSerialize;
template <typename T> struct TIsPODType;
 
 
enum class EGuidFormats
{
    Digits,
 
     DigitsLower,
 
    DigitsWithHyphens,
 
    DigitsWithHyphensLower,
 
    DigitsWithHyphensInBraces,
 
    DigitsWithHyphensInParentheses,
 
    HexValuesInBraces,
 
    UniqueObjectGuid,
 
    Short,
 
    Base36Encoded,
};
 
struct FGuid
{
public:
 
    constexpr FGuid()
        : A(0)
        , B(0)
        , C(0)
        , D(0)
    { }
 
    explicit constexpr FGuid(uint32 InA, uint32 InB, uint32 InC, uint32 InD)
        : A(InA), B(InB), C(InC), D(InD)
    { }
 
    explicit FGuid(const FString& InGuidStr)
    {
        if (!Parse(InGuidStr, *this))
        {
            Invalidate();
        }
    }
 
public:
 
    friend bool operator==(const FGuid& X, const FGuid& Y)
    {
        return ((X.A ^ Y.A) | (X.B ^ Y.B) | (X.C ^ Y.C) | (X.D ^ Y.D)) == 0;
    }
 
    friend bool operator!=(const FGuid& X, const FGuid& Y)
    {
        return ((X.A ^ Y.A) | (X.B ^ Y.B) | (X.C ^ Y.C) | (X.D ^ Y.D)) != 0;
    }
 
    friend bool operator<(const FGuid& X, const FGuid& Y)
    {
        return  ((X.A < Y.A) ? true : ((X.A > Y.A) ? false :
                ((X.B < Y.B) ? true : ((X.B > Y.B) ? false :
                ((X.C < Y.C) ? true : ((X.C > Y.C) ? false :
                ((X.D < Y.D) ? true : ((X.D > Y.D) ? false : false)))))))); //-V583
    }
 
    uint32& operator[](int32 Index)
    {
        checkSlow(Index >= 0);
        checkSlow(Index < 4);
 
        switch(Index)
        {
        case 0: return A;
        case 1: return B;
        case 2: return C;
        case 3: return D;
        }
 
        return A;
    }
 
    const uint32& operator[](int32 Index) const
    {
        checkSlow(Index >= 0);
        checkSlow(Index < 4);
 
        switch(Index)
        {
        case 0: return A;
        case 1: return B;
        case 2: return C;
        case 3: return D;
        }
 
        return A;
    }
 
    CORE_API friend FArchive& operator<<(FArchive& Ar, FGuid& G);
 
    CORE_API friend void operator<<(FStructuredArchive::FSlot Slot, FGuid& G);
 
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    friend FString LexToString(const FGuid& Value)
    {
        return Value.ToString();
    }
 
    friend void LexFromString(FGuid& Result, const TCHAR* String)
    {
        FGuid::Parse(String, Result);
    }
 
    bool Serialize(FStructuredArchive::FSlot Slot)
    {
        Slot << *this;
        return true;
    }
 
    // Allows a FGuid to be returned from AutoRTFM::Open().
    // See AutoRTFM::Open().
    static inline void AutoRTFMAssignFromOpenToClosed(FGuid& Closed, FGuid Open)
    {
        Closed = Open;
    }
 
public:
 
    CORE_API bool ExportTextItem(FString& ValueStr, FGuid const& DefaultValue, UObject* Parent, int32 PortFlags, class UObject* ExportRootScope) const;
 
    CORE_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
 
    void Invalidate()
    {
        A = B = C = D = 0;
    }
 
    bool IsValid() const
    {
        return ((A | B | C | D) != 0);
    }
 
    FString ToString(EGuidFormats Format = EGuidFormats::Digits) const
    {
        FString Out;
        AppendString(Out, Format);
        return Out;
    }
 
    CORE_API void AppendString(FString& Out, EGuidFormats Format = EGuidFormats::Digits) const;
 
    CORE_API void AppendString(FAnsiStringBuilderBase& Builder, EGuidFormats Format = EGuidFormats::DigitsWithHyphensLower) const;
    CORE_API void AppendString(FUtf8StringBuilderBase& Builder, EGuidFormats Format = EGuidFormats::DigitsWithHyphensLower) const;
    CORE_API void AppendString(FWideStringBuilderBase& Builder, EGuidFormats Format = EGuidFormats::DigitsWithHyphensLower) const;
 
public:
 
    [[nodiscard]] friend uint32 GetTypeHash(const FGuid& Guid)
    {
        return uint32(CityHash64((char*)&Guid, sizeof(FGuid)));
    }
 
public:
 
    static CORE_API FGuid NewGuid();
    static CORE_API FGuid NewDeterministicGuid(FStringView ObjectPath, uint64 Seed = 0);
    static CORE_API FGuid NewGuidFromHash(const FBlake3Hash& Hash);
 
    static CORE_API FGuid NewGuidFromHashBytes(const void* HashData, int64 DataLen);
 
    static CORE_API FGuid Combine(const FGuid& GuidA, const FGuid& GuidB);
 
    static CORE_API bool Parse(const TCHAR* GuidString, FGuid& OutGuid);
    static CORE_API bool Parse(const FString& GuidString, FGuid& OutGuid);
    static CORE_API bool Parse(FStringView GuidString, FGuid& OutGuid);
 
    static CORE_API bool ParseExact(const TCHAR* GuidString, EGuidFormats Format, FGuid& OutGuid);
    static CORE_API bool ParseExact(const FString& GuidString, EGuidFormats Format, FGuid& OutGuid);
    static CORE_API bool ParseExact(FStringView GuidString, EGuidFormats Format, FGuid& OutGuid);
 
//private:
public:
 
    uint32 A;
 
    uint32 B;
 
    uint32 C;
 
    uint32 D;
};
template<> struct TCanBulkSerialize<FGuid> { enum { Value = true }; };
DECLARE_INTRINSIC_TYPE_LAYOUT(FGuid);
 
template <> struct TIsPODType<FGuid> { enum { Value = true }; };
 
template <typename CharType>
inline TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const FGuid& Value)
{
    Value.AppendString(Builder);
    return Builder;
}