CustomVersion.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Misc/Crc.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
class FArchive;
class FCustomVersionContainer;
struct FCustomVersion;
 
enum class ECustomVersionSerializationFormat : uint8
{
    Unknown,
    Guids,
    Enums,
    Optimized,
 
    // Add new versions above this comment
    CustomVersion_Automatic_Plus_One,
    Latest = CustomVersion_Automatic_Plus_One - 1
};
 
typedef TArray<FCustomVersion> FCustomVersionArray;
typedef bool (*CustomVersionValidatorFunc)(const FCustomVersion& Version, const FCustomVersionArray& AllVersions, const TCHAR* DebugContext);
 
struct FCustomVersion
{
    friend class FCustomVersionContainer;
 
    FGuid Key;
 
    int32 Version;
 
    int32 ReferenceCount;
 
    CustomVersionValidatorFunc Validator;
 
    UE_FORCEINLINE_HINT FCustomVersion()
    : Validator(nullptr)
    {
    }
 
    inline FCustomVersion(FGuid InKey, int32 InVersion, FName InFriendlyName, CustomVersionValidatorFunc InValidatorFunc = nullptr)
    : Key           (InKey)
    , Version       (InVersion)
    , ReferenceCount(1)
    , Validator     (InValidatorFunc)
    , FriendlyName  (InFriendlyName)
    {
    }
 
    UE_FORCEINLINE_HINT bool operator==(FGuid InKey) const
    {
        return Key == InKey;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(FGuid InKey) const
    {
        return Key != InKey;
    }
 
    CORE_API friend FArchive& operator<<(FArchive& Ar, FCustomVersion& Version);
    CORE_API friend void operator<<(FStructuredArchive::FSlot Slot, FCustomVersion& Version);
 
    CORE_API const FName GetFriendlyName() const;
 
private:
 
    mutable FName FriendlyName;
};
 
class FCustomVersionRegistration;
 
enum class ESetCustomVersionFlags : uint8
{
    None,
 
    // If Set, it will not query the versions registry to update the version data if the key is already in the container 
    SkipUpdateExistingVersion = 0x01,
};
ENUM_CLASS_FLAGS(ESetCustomVersionFlags)
 
 
class FCustomVersionContainer
{
    friend struct FStaticCustomVersionRegistry;
 
public:
    UE_FORCEINLINE_HINT const FCustomVersionArray& GetAllVersions() const
    {
        return Versions;
    }
 
    CORE_API const FCustomVersion* GetVersion(FGuid CustomKey) const;
 
    CORE_API const FName GetFriendlyName(FGuid CustomKey) const;
 
    CORE_API void SetVersion(FGuid CustomKey, int32 Version, FName FriendlyName);
 
    CORE_API void SetVersionUsingRegistry(FGuid CustomKey, ESetCustomVersionFlags Options = ESetCustomVersionFlags::None);
 
    CORE_API void Serialize(FArchive& Ar, ECustomVersionSerializationFormat Format = ECustomVersionSerializationFormat::Latest);
    CORE_API void Serialize(FStructuredArchive::FSlot Slot, ECustomVersionSerializationFormat Format = ECustomVersionSerializationFormat::Latest);
 
    UE_DEPRECATED(4.24, "Use one of the thread-safe FCurrentCustomVersions methods instead")
    static CORE_API const FCustomVersionContainer& GetRegistered();
 
    CORE_API void Empty();
 
    CORE_API void SortByKey();
 
    CORE_API FString ToString(const FString& Indent) const;
 
private:
 
    FCustomVersionArray Versions;
 
};
 
enum class ECustomVersionDifference { Missing, Newer, Older, Invalid };
 
struct FCustomVersionDifference
{
    ECustomVersionDifference Type;
    const FCustomVersion* Version;
};
 
class FCurrentCustomVersions
{
public:
    static CORE_API FCustomVersionContainer GetAll();
 
    static CORE_API TOptional<FCustomVersion> Get(const FGuid& Guid);
 
    static CORE_API TArray<FCustomVersionDifference> Compare(const FCustomVersionArray& CompareVersions, const TCHAR* DebugContext);
 
private:
    friend class FCustomVersionRegistration;
 
    static CORE_API void Register(const FGuid& Key, int32 Version, const TCHAR* FriendlyName, CustomVersionValidatorFunc ValidatorFunc);
    static CORE_API void Unregister(const FGuid& Key);
};
 
 
class FCustomVersionRegistration : FNoncopyable
{
public:
    template<int N>
    FCustomVersionRegistration(FGuid InKey, int32 Version, const TCHAR(&InFriendlyName)[N], CustomVersionValidatorFunc InValidatorFunc = nullptr)
    : Key(InKey)
    {
        FCurrentCustomVersions::Register(InKey, Version, InFriendlyName, InValidatorFunc);
    }
 
    ~FCustomVersionRegistration()
    {
        FCurrentCustomVersions::Unregister(Key);
    }
 
private:
    FGuid Key;
};