Archive.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreFwd.h"
#include "CoreTypes.h"
#include "HAL/PlatformProperties.h"
#include "Internationalization/TextNamespaceFwd.h"
#include "Math/MathFwd.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Build.h"
#include "Misc/CompressionFlags.h"
#include "Misc/EngineVersionBase.h"
#include "Misc/VarArgs.h"
#include "Serialization/ArchiveCookData.h"
#include "Serialization/ArchiveSavePackageData.h"
#include "Templates/EnableIf.h"
#include "Templates/IsArrayOrRefOfTypeByPredicate.h"
#include "Templates/IsEnumClass.h"
#include "Templates/IsSigned.h"
#include "Templates/IsValidVariadicFunctionArg.h"
#include "Templates/UnrealTemplate.h"
#include "Traits/IsCharEncodingCompatibleWith.h"
#include "UObject/ObjectVersion.h"
 
class FArchive;
class FBulkData;
class FCustomVersionContainer;
class FLinker;
class FName;
class FProperty;
class FString;
class FText;
class ITargetPlatform;
class UObject;
namespace Verse { struct VCell; }
namespace UE::Serialization{ class FEditorBulkData; }
struct FArchiveSerializedPropertyChain;
struct FBulkDataSerializationParams;
struct FCompressedChunk;
template <typename TEnum> class TEnumAsByte;
template <typename FuncType> class TFunction;
template <typename T> struct TObjectPtr;
 
typedef TFunction<bool (double RemainingTime)> FExternalReadCallback;
class FField;
struct FUObjectMigrationContext;
struct FUObjectSerializeContext;
 
enum class EFileRegionType : uint8;
struct FArchiveCookContext;
 
// Temporary while we shake out the EDL at boot
#define USE_EVENT_DRIVEN_ASYNC_LOAD_AT_BOOT_TIME (1)
 
#if USE_EVENT_DRIVEN_ASYNC_LOAD_AT_BOOT_TIME
    #define EVENT_DRIVEN_ASYNC_LOAD_ACTIVE_AT_RUNTIME (1)
#else
    #define EVENT_DRIVEN_ASYNC_LOAD_ACTIVE_AT_RUNTIME (!GIsInitialLoad) 
#endif
 
#define DEVIRTUALIZE_FLinkerLoad_Serialize (!WITH_EDITORONLY_DATA)
 
// Helper macro to make serializing a bitpacked boolean in an archive easier. 
// NOTE: The condition is there to avoid overwriting a value that is the same, especially important to make saving an immutable operation and avoid dirtying cachelines for nothing.
//       This will also make TSAN happy when multiple threads are hitting the same bitfield during concurrent saves.
#define FArchive_Serialize_BitfieldBool(ARCHIVE, BITFIELD_BOOL) { bool TEMP_BITFIELD_BOOL = BITFIELD_BOOL; ARCHIVE << TEMP_BITFIELD_BOOL; if (BITFIELD_BOOL != TEMP_BITFIELD_BOOL) { BITFIELD_BOOL = TEMP_BITFIELD_BOOL; } }
 
struct FArchiveState
{
private:
    // Only FArchive is allowed to instantiate this, by inheritance
    friend class FArchive;
 
    CORE_API FArchiveState();
 
    CORE_API FArchiveState(const FArchiveState&);
 
    CORE_API FArchiveState& operator=(const FArchiveState& ArchiveToCopy);
 
    CORE_API virtual ~FArchiveState() = 0;
 
protected:
    static CORE_API void LinkProxy(FArchiveState& Inner, FArchiveState& Proxy);
    static CORE_API void UnlinkProxy(FArchiveState& Inner, FArchiveState& Proxy);
 
public:
    virtual FArchiveState& GetInnermostState()
    {
        return *this;
    }
 
    CORE_API void SetArchiveState(const FArchiveState& InState);
 
    CORE_API void SetError();
 
    CORE_API void ClearError();
 
    CORE_API void SetCriticalError();
 
    virtual void CountBytes(SIZE_T InNum, SIZE_T InMax) { }
 
    CORE_API virtual FString GetArchiveName() const;
 
    virtual FLinker* GetLinker()
    {
        return nullptr;
    }
 
    virtual int64 Tell()
    {
        return INDEX_NONE;
    }
 
    virtual int64 TotalSize()
    {
        return INDEX_NONE;
    }
 
    virtual bool AtEnd()
    {
        int64 Pos = Tell();
 
        return ((Pos != INDEX_NONE) && (Pos >= TotalSize()));
    }
 
    inline bool IsByteSwapping()
    {
    #if PLATFORM_LITTLE_ENDIAN
        bool SwapBytes = ArForceByteSwapping;
    #else
        bool SwapBytes = this->IsPersistent();
    #endif
        return SwapBytes;
    }
 
    void ThisContainsCode()
    {
        ArContainsCode = true;
    }
 
    void ThisContainsMap()
    {
        ArContainsMap = true;
    }
 
    CORE_API void ThisRequiresLocalizationGather();
 
    virtual UObject* GetArchetypeFromLoader(const UObject* Obj)
    {
        return nullptr;
    }
 
    UE_FORCEINLINE_HINT FPackageFileVersion UEVer() const
    {
        return ArUEVer;
    }
 
    UE_FORCEINLINE_HINT int32 LicenseeUEVer() const
    {
        return ArLicenseeUEVer;
    }
 
    UE_FORCEINLINE_HINT FEngineVersionBase EngineVer() const
    {
        return ArEngineVer;
    }
 
    CORE_API virtual uint32 EngineNetVer() const;
 
    CORE_API virtual uint32 GameNetVer() const;
 
    CORE_API int32 CustomVer(const struct FGuid& Key) const;
 
    UE_FORCEINLINE_HINT bool IsLoading() const
    {
        return ArIsLoading;
    }
 
    UE_FORCEINLINE_HINT bool IsLoadingFromCookedPackage() const
    {
        return ArIsLoadingFromCookedPackage;
    }
 
    UE_FORCEINLINE_HINT bool IsSaving() const
    {
        return ArIsSaving;
    }
 
    inline bool IsTransacting() const
    {
        if (FPlatformProperties::HasEditorOnlyData())
        {
            return ArIsTransacting;
        }
        else
        {
            return false;
        }
    }
 
    UE_FORCEINLINE_HINT bool IsTextFormat() const
    {
        return (ArIsTextFormat && WITH_TEXT_ARCHIVE_SUPPORT);
    }
 
    UE_FORCEINLINE_HINT bool WantBinaryPropertySerialization() const
    {
        return ArWantBinaryPropertySerialization;
    }
 
    UE_FORCEINLINE_HINT bool UseUnversionedPropertySerialization() const
    {
        return ArUseUnversionedPropertySerialization;
    }
 
    UE_FORCEINLINE_HINT bool IsForcingUnicode() const
    {
        return ArForceUnicode;
    }
 
    UE_FORCEINLINE_HINT bool IsPersistent() const
    {
        return ArIsPersistent;
    }
 
    void SetShouldSkipCompilingAssets(bool Enabled)
    {
        ArShouldSkipCompilingAssets = Enabled;
    }
 
    UE_FORCEINLINE_HINT bool ShouldSkipCompilingAssets() const
    {
        return ArShouldSkipCompilingAssets;
    }
 
    CORE_API void SetShouldSkipUpdateCustomVersion(bool bShouldSkip);
 
    UE_FORCEINLINE_HINT bool ShouldSkipUpdateCustomVersion() const
    {
        return ArShouldSkipUpdateCustomVersion;
    }
 
    CORE_API void SetMigratingRemoteObjects(bool bMigrating);
 
    virtual const FUObjectMigrationContext* GetMigrationContext() const
    {
        return nullptr;
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    UE_FORCEINLINE_HINT bool IsMigratingRemoteObjects() const
    {
        return ArIsMigratingRemoteObjects;
    }
#else
    UE_FORCEINLINE_HINT constexpr bool IsMigratingRemoteObjects() const
    {
        return false;
    }
#endif // UE_WITH_REMOTE_OBJECT_HANDLE
 
    UE_FORCEINLINE_HINT bool IsError() const
    {
        return ArIsError;
    }
 
    UE_FORCEINLINE_HINT bool GetError() const
    {
        return ArIsError;
    }
 
    UE_FORCEINLINE_HINT bool IsCriticalError() const
    {
        return ArIsCriticalError;
    }
 
    UE_FORCEINLINE_HINT bool ContainsCode() const
    {
        return ArContainsCode;
    }
 
    UE_FORCEINLINE_HINT bool ContainsMap() const
    {
        return ArContainsMap;
    }
 
    inline bool RequiresLocalizationGather() const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return ArRequiresLocalizationGather;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_FORCEINLINE_HINT bool ForceByteSwapping() const
    {
        return ArForceByteSwapping;
    }
 
    UE_FORCEINLINE_HINT bool IsSerializingDefaults() const
    {
        return (ArSerializingDefaults > 0) ? true : false;
    }
 
    UE_FORCEINLINE_HINT bool IsIgnoringArchetypeRef() const
    {
        return ArIgnoreArchetypeRef;
    }
 
    UE_FORCEINLINE_HINT bool DoDelta() const
    {
        return !ArNoDelta;
    }
 
    UE_FORCEINLINE_HINT bool DoIntraPropertyDelta() const
    {
        return !ArNoIntraPropertyDelta;
    }
 
    UE_FORCEINLINE_HINT bool IsIgnoringOuterRef() const
    {
        return ArIgnoreOuterRef;
    }
 
    UE_FORCEINLINE_HINT bool IsIgnoringClassGeneratedByRef() const
    {
        return ArIgnoreClassGeneratedByRef;
    }
 
    UE_FORCEINLINE_HINT bool IsIgnoringClassRef() const
    {
        return ArIgnoreClassRef;
    }
 
    UE_FORCEINLINE_HINT bool IsAllowingLazyLoading() const
    {
        return ArAllowLazyLoading;
    }
 
    UE_FORCEINLINE_HINT bool IsObjectReferenceCollector() const
    {
        return ArIsObjectReferenceCollector;
    }
 
    UE_FORCEINLINE_HINT bool IsModifyingWeakAndStrongReferences() const
    {
        return ArIsModifyingWeakAndStrongReferences;
    }
 
    UE_FORCEINLINE_HINT bool IsCountingMemory() const
    {
        return ArIsCountingMemory;
    }
 
    UE_FORCEINLINE_HINT uint32 GetPortFlags() const
    {
        return ArPortFlags;
    }
 
    UE_FORCEINLINE_HINT bool HasAnyPortFlags(uint32 Flags) const
    {
        return ((ArPortFlags & Flags) != 0);
    }
 
    UE_FORCEINLINE_HINT bool HasAllPortFlags(uint32 Flags) const
    {
        return ((ArPortFlags & Flags) == Flags);
    }
 
    inline uint32 GetDebugSerializationFlags() const
    {
#if WITH_EDITOR
        return ArDebugSerializationFlags;
#else
        return 0;
#endif
    }
 
    UE_FORCEINLINE_HINT bool ShouldSkipBulkData() const
    {
        return ArShouldSkipBulkData;
    }
 
    UE_FORCEINLINE_HINT int64 GetMaxSerializeSize() const
    {
        return ArMaxSerializeSize;
    }
 
    CORE_API virtual const FCustomVersionContainer& GetCustomVersions() const;
 
    CORE_API virtual void SetCustomVersions(const FCustomVersionContainer& CustomVersionContainer);
 
    CORE_API virtual void ResetCustomVersions();
 
    CORE_API void SetCustomVersion(const struct FGuid& Key, int32 Version, FName FriendlyName);
 
    void SetByteSwapping(bool Enabled)
    {
        ArForceByteSwapping = Enabled;
    }
 
    void SetPortFlags(uint32 InPortFlags)
    {
        ArPortFlags = InPortFlags;
    }
 
    virtual void SetDebugSerializationFlags(uint32 InCustomFlags)
    {
#if WITH_EDITOR
        ArDebugSerializationFlags = InCustomFlags;
#endif
    }
 
    bool IsFilterEditorOnly() const
    {
        return ArIsFilterEditorOnly;
    }
 
    virtual void SetFilterEditorOnly(bool InFilterEditorOnly)
    {
        ArIsFilterEditorOnly = InFilterEditorOnly;
    }
 
    bool IsSavingOptionalObject () const
    {
        return ArIsSavingOptionalObject;
    }
 
    virtual void SetSavingOptionalObject(bool InSavingOptionalObject)
    {
        check(IsSaving());
        ArIsSavingOptionalObject = InSavingOptionalObject;
    }
 
    bool IsSaveGame() const
    {
        return ArIsSaveGame;
    }
 
    UE_FORCEINLINE_HINT bool IsNetArchive() const
    {
        return ArIsNetArchive;
    }
 
    UE_FORCEINLINE_HINT bool IsCooking() const
    {
        return SavePackageData && SavePackageData->CookContext;
    }
 
    void SetSavePackageData(FArchiveSavePackageData* InSavePackageData)
    {
        checkf(!(InSavePackageData == nullptr && SavePackageData), TEXT("Can't turn off cooking once you turn it on!"));
 
        if (InSavePackageData)
        {
            check(!IsLoading() && !IsTransacting() && IsSaving());
            SavePackageData = InSavePackageData;
        }
 
    }
 
    FArchiveSavePackageData* GetSavePackageData()
    {
        return SavePackageData;
    }
 
    UE_DEPRECATED(5.5, "Use SetSavePackageData.")
    void SetCookData(FArchiveCookData* InCookData)
    {
        // Backwards compatibility for this function is not supported because of the low amount of public usage and the
        // cost of supporting the backwards compatability (extra memory on FArchiveSavePackageData). Change your code
        // to use SetSavePackageData, or contact Epic for assistance in adding the backwards compatibility.
        check(false);
    }
 
    UE_DEPRECATED(5.5, "Use GetCookContext or CookingTarget or GetSavePackageData.")
    FArchiveCookData* GetCookData()
    {
        // Backwards compatibility for this function is not supported because of the low amount of public usage and the
        // cost of supporting the backwards compatability (extra memory on FArchiveSavePackageData). Change your code
        // to use GetCookContext or CookingTarget or GetSavePackageData, or contact Epic for assistance.
        check(false);
        return nullptr;
    }
 
    UE_FORCEINLINE_HINT FArchiveCookContext* GetCookContext()
    {
        return SavePackageData ? SavePackageData->CookContext : nullptr;
    }
 
    UE_FORCEINLINE_HINT const ITargetPlatform* CookingTarget() const
    {
        return SavePackageData ? SavePackageData->TargetPlatform : nullptr;
    }
 
    FObjectSavePackageSerializeContext* GetSavePackageSerializeContext()
    {
        return SavePackageData ? &SavePackageData->SavePackageContext : nullptr;
    }
 
    virtual bool UseToResolveEnumerators() const
    {
        return false;
    }
 
    virtual bool ShouldSkipProperty(const FProperty* InProperty) const
    {
        return false;
    }
 
    virtual void SetSerializedProperty(FProperty* InProperty)
    {
        SerializedProperty = InProperty;
    }
 
    UE_FORCEINLINE_HINT class FProperty* GetSerializedProperty() const
    {
        return SerializedProperty;
    }
 
    CORE_API void GetSerializedPropertyChain(TArray<class FProperty*>& OutProperties) const;
 
    UE_FORCEINLINE_HINT const FArchiveSerializedPropertyChain* GetSerializedPropertyChain() const
    {
        return SerializedPropertyChain;
    }
 
    CORE_API virtual void SetSerializedPropertyChain(const FArchiveSerializedPropertyChain* InSerializedPropertyChain, class FProperty* InSerializedPropertyOverride = nullptr);
 
#if WITH_EDITORONLY_DATA
    CORE_API virtual bool IsEditorOnlyPropertyOnTheStack() const;
#endif
 
    UE_DEPRECATED(5.5, "SetSerializeContext is not supported. Remove calls to it.")
    virtual void SetSerializeContext(FUObjectSerializeContext* InLoadContext) {}
 
    UE_DEPRECATED(5.5, "GetSerializeContext is not supported. Use FUObjectThreadContext::Get().GetSerializeContext().")
    virtual FUObjectSerializeContext* GetSerializeContext() { return nullptr; }
 
#if USE_STABLE_LOCALIZATION_KEYS
    CORE_API virtual void SetLocalizationNamespace(const FString& InLocalizationNamespace);
 
    CORE_API virtual FString GetLocalizationNamespace() const;
#endif // USE_STABLE_LOCALIZATION_KEYS
 
    CORE_API virtual void Reset();
 
public:
    /* These are used for fastpath inline serializers  */
    struct FFastPathLoadBuffer
    {
        const uint8* StartFastPathLoadBuffer;
        const uint8* EndFastPathLoadBuffer;
        const uint8* OriginalFastPathLoadBuffer;
        UE_FORCEINLINE_HINT FFastPathLoadBuffer()
        {
            Reset();
        }
        inline void Reset()
        {
            StartFastPathLoadBuffer = nullptr;
            EndFastPathLoadBuffer = nullptr;
            OriginalFastPathLoadBuffer = nullptr;
        }
    };
#if DEVIRTUALIZE_FLinkerLoad_Serialize
    //@todoio FArchive is really a horrible class and the way it is proxied by FLinkerLoad is double terrible. It makes the fast path really hacky and slower than it would need to be.
    FFastPathLoadBuffer* ActiveFPLB;
    FFastPathLoadBuffer InlineFPLB;
#endif
 
// These will be private in FArchive
protected:
    CORE_API void CopyTrivialFArchiveStatusMembers(const FArchiveState& ArchiveStatusToCopy);
 
    uint8 ArIsLoading : 1;
 
    uint8 ArIsLoadingFromCookedPackage : 1;
 
    uint8 ArIsSaving : 1;
 
    uint8 ArIsTransacting : 1;
 
    uint8 ArIsTextFormat : 1;
 
    uint8 ArWantBinaryPropertySerialization : 1;
 
    uint8 ArUseUnversionedPropertySerialization : 1;
 
    uint8 ArForceUnicode : 1;
 
    uint8 ArIsPersistent : 1;
 
private:
    uint8 ArIsError : 1;
 
    uint8 ArIsCriticalError : 1;
 
    uint8 ArShouldSkipCompilingAssets : 1;
 
    uint8 ArShouldSkipUpdateCustomVersion : 1;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    uint8 ArIsMigratingRemoteObjects : 1;
#endif
 
public:
    uint8 ArContainsCode : 1;
 
    uint8 ArContainsMap : 1;
 
    UE_DEPRECATED(5.6, "Public access to ArRequiresLocalizationGather has been deprecated - please use Ar.RequiresLocalizationGather() and Ar.ThisRequiresLocalizationGather() for getting and setting respectively.")
    uint8 ArRequiresLocalizationGather : 1;
 
    uint8 ArForceByteSwapping : 1;
 
    uint8 ArIgnoreArchetypeRef : 1;
 
    uint8 ArNoDelta : 1;
 
    uint8 ArNoIntraPropertyDelta : 1;
 
    uint8 ArIgnoreOuterRef : 1;
 
    uint8 ArIgnoreClassGeneratedByRef : 1;
 
    uint8 ArIgnoreClassRef : 1;
 
    uint8 ArAllowLazyLoading : 1;
 
    uint8 ArIsObjectReferenceCollector : 1;
 
    uint8 ArIsModifyingWeakAndStrongReferences : 1;
 
    uint8 ArIsCountingMemory : 1;
 
    uint8 ArShouldSkipBulkData : 1;
 
    uint8 ArIsFilterEditorOnly : 1;
 
    uint8 ArIsSavingOptionalObject : 1;
 
    uint8 ArIsSaveGame : 1;
 
    uint8 ArIsNetArchive : 1;
 
    uint8 ArUseCustomPropertyList : 1;
 
    uint8 ArMergeOverrides : 1;
 
    uint8 ArPreserveArrayElements : 1;
 
    int32 ArSerializingDefaults;
 
    uint32 ArPortFlags;
 
    int64 ArMaxSerializeSize;
 
    CORE_API virtual void SetIsLoading(bool bInIsLoading);
 
    CORE_API virtual void SetIsLoadingFromCookedPackage(bool bInIsLoadingFromCookedPackage);
 
    CORE_API virtual void SetIsSaving(bool bInIsSaving);
 
    CORE_API virtual void SetIsTransacting(bool bInIsTransacting);
 
    CORE_API virtual void SetIsTextFormat(bool bInIsTextFormat);
 
    CORE_API virtual void SetWantBinaryPropertySerialization(bool bInWantBinaryPropertySerialization);
 
    CORE_API virtual void SetUseUnversionedPropertySerialization(bool bInUseUnversioned);
 
    CORE_API virtual void SetForceUnicode(bool bInForceUnicode);
 
    CORE_API virtual void SetIsPersistent(bool bInIsPersistent);
 
    CORE_API virtual void SetUEVer(FPackageFileVersion InVer);
 
    CORE_API virtual void SetLicenseeUEVer(int32 InVer);
 
    CORE_API virtual void SetEngineVer(const FEngineVersionBase& InVer);
 
    CORE_API virtual void SetEngineNetVer(const uint32 InEngineNetVer);
 
    CORE_API virtual void SetGameNetVer(const uint32 InGameNetVer);
 
// These will be private in FArchive
protected:
    FPackageFileVersion ArUEVer;
 
    int32 ArLicenseeUEVer;
 
    FEngineVersionBase ArEngineVer;
 
    mutable FCustomVersionContainer* CustomVersionContainer = nullptr;
 
public:
    const struct FCustomPropertyListNode* ArCustomPropertyList;
 
#if WITH_EDITOR
    uint32 ArDebugSerializationFlags;
#endif
 
// These will be private in FArchive
protected:
    FArchiveSavePackageData* SavePackageData = nullptr;
    
    FProperty* SerializedProperty;
 
    FArchiveSerializedPropertyChain* SerializedPropertyChain;
 
#if USE_STABLE_LOCALIZATION_KEYS
    FString* LocalizationNamespacePtr;
 
    CORE_API FString GetBaseLocalizationNamespace() const;
 
    CORE_API void SetBaseLocalizationNamespace(const FString& InLocalizationNamespace);
#endif // USE_STABLE_LOCALIZATION_KEYS
 
    mutable bool bCustomVersionsAreReset;
 
private:
    FArchiveState* NextProxy = nullptr;
 
    template<typename T> void ForEachState(T Func);
};
 
template<class T> class TCheckedObjPtr
{
    friend class FArchive;
 
public:
    TCheckedObjPtr()
        : Object(nullptr)
        , bError(false)
    {
    }
 
    TCheckedObjPtr(T* InObject)
        : Object(InObject)
        , bError(false)
    {
    }
 
    inline TCheckedObjPtr& operator = (T* InObject)
    {
        Object = InObject;
 
        return *this;
    }
 
    UE_FORCEINLINE_HINT T* operator -> () const
    {
        return Object;
    }
 
    UE_FORCEINLINE_HINT T*& Get()
    {
        return Object;
    }
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return Object != nullptr;
    }
 
    UE_FORCEINLINE_HINT bool IsError() const
    {
        return bError;
    }
 
private:
    T* Object;
 
    bool bError;
};
 
 
class FArchive : private FArchiveState
{
public:
    FArchive() = default;
    FArchive(const FArchive&) = default;
    FArchive& operator=(const FArchive& ArchiveToCopy) = default;
    CORE_API virtual ~FArchive();
 
protected:
    using FArchiveState::LinkProxy;
    using FArchiveState::UnlinkProxy;
    using FArchiveState::FFastPathLoadBuffer;
 
public:
 
    virtual FArchive& operator<<(FName& Value)
    {
        return *this;
    }
 
    CORE_API virtual FArchive& operator<<(FText& Value);
 
    virtual FArchive& operator<<(UObject*& Value)
    {
        return *this;
    }
 
    virtual FArchive& operator<<(FField*& Value)
    {
        return *this;
    }
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    virtual FArchive& operator<<(Verse::VCell*& Value)
    {
        return *this;
    }
#endif
 
    template<class T> inline FArchive& operator<<(TCheckedObjPtr<T>& Value)
    {
        Value.bError = false;
 
        if (IsSaving())
        {
            UObject* SerializeObj = nullptr;
 
            if (Value.IsValid())
            {
                if (Value.Get()->IsA(T::StaticClass()))
                {
                    SerializeObj = Value.Get();
                }
                else
                {
                    Value.bError = true;
                }
            }
 
            *this << SerializeObj;
        }
        else
        {
            *this << Value.Get();
 
            if (IsLoading() && Value.IsValid() && !Value.Get()->IsA(T::StaticClass()))
            {
                Value.bError = true;
                Value = nullptr;
            }
        }
 
        return *this;
    }
 
    CORE_API virtual FArchive& operator<<(struct FLazyObjectPtr& Value);
 
    CORE_API virtual FArchive& operator<<(struct FObjectPtr& Value);
    
    CORE_API virtual FArchive& operator<<(struct FSoftObjectPtr& Value);
 
    CORE_API virtual FArchive& operator<<(struct FSoftObjectPath& Value);
 
    CORE_API virtual FArchive& operator<<(struct FWeakObjectPtr& Value);
 
    virtual void ForceBlueprintFinalization() {}
 
    inline friend FArchive& operator<<(FArchive& Ar, ANSICHAR& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.Serialize(&Value, 1);
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, WIDECHAR& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(&Value, sizeof(Value));
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, UTF32CHAR& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(&Value, sizeof(Value));
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, uint8& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.Serialize(&Value, 1);
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, int8& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.Serialize(&Value, 1);
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, uint16& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(Value);
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, int16& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(reinterpret_cast<uint16&>(Value));
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, uint32& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(Value);
        }
        return Ar;
    }
 
#if WITH_EDITOR
protected:
    CORE_API virtual void SerializeBool( bool& D );
public:
    inline friend FArchive& operator<<(FArchive& Ar, bool& D)
    {
        Ar.SerializeBool(D);
        return Ar;
    }
#else
    inline friend FArchive& operator<<( FArchive& Ar, bool& D )
    {
        // Serialize bool as if it were UBOOL (legacy, 32 bit int).
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        const uint8 * RESTRICT Src = Ar.ActiveFPLB->StartFastPathLoadBuffer;
        if (Src + sizeof(uint32) <= Ar.ActiveFPLB->EndFastPathLoadBuffer)
        {
            D = !!FPlatformMemory::ReadUnaligned<uint32>(Src);
            Ar.ActiveFPLB->StartFastPathLoadBuffer += 4;
        }
        else
#endif
        {
            uint32 OldUBoolValue = 0;
 
            if (!Ar.IsLoading())
            {
                // Only read from the input if we aren't loading its value.
                // This avoids triggering UBSAN by unnecessarily coercing uninitialized memory to a bool.
                OldUBoolValue = D ? 1 : 0;
            }
 
            Ar.Serialize(&OldUBoolValue, sizeof(OldUBoolValue));
 
            if (OldUBoolValue > 1)
            {
                Ar.SetError();
            }
 
            if (Ar.IsLoading())
            {
                // Only write to our input if we are loading to make sure we don't
                // write to 'read-only' memory (e.g. FMemoryWriter) as this can cause TSAN
                // validation races
                D = !!OldUBoolValue;
            }
        }
        return Ar;
    }
#endif
 
    inline friend FArchive& operator<<(FArchive& Ar, int32& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(reinterpret_cast<uint32&>(Value));
        }
        return Ar;
    }
 
#if PLATFORM_COMPILER_DISTINGUISHES_INT_AND_LONG
    inline friend FArchive& operator<<(FArchive& Ar, long& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(reinterpret_cast<unsigned long&>(Value));
        }
        return Ar;
    }   
#endif
 
    inline friend FArchive& operator<<( FArchive& Ar, float& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            static_assert(sizeof(float) == sizeof(uint32), "Expected float to be 4 bytes to swap as uint32");
            Ar.ByteOrderSerialize(reinterpret_cast<uint32&>(Value));
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, double& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            static_assert(sizeof(double) == sizeof(uint64), "Expected double to be 8 bytes to swap as uint64");
            Ar.ByteOrderSerialize(reinterpret_cast<uint64&>(Value));
        }
        return Ar;
    }
 
    inline friend FArchive& operator<<(FArchive &Ar, uint64& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(Value);
        }
        return Ar;
    }
 
    /*inline*/friend FArchive& operator<<(FArchive& Ar, int64& Value)
    {
#if DEVIRTUALIZE_FLinkerLoad_Serialize
        if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
        {
            Ar.ByteOrderSerialize(reinterpret_cast<uint64&>(Value));
        }
        return Ar;
    }
 
    friend CORE_API FArchive& operator<<(FArchive& Ar, FString& Value);
 
public:
    virtual void Serialize(void* V, int64 Length)
    {
#if defined(__clang_analyzer__)
        // Suppress core.uninitialized.Assign static analysis warning
        // Base class FArchive::Serialize() does not modify the value being serialized, so the analysis
        // assumes any data being serialized to could be uninitialized, but practically speaking any
        // data being serialized will use a derived class that always modifies the value.
        memset(V, 0, Length);
#endif
    }
 
#define SerializeBitfield(Ar, BitField) \
    { \
        bool PREPROCESSOR_JOIN(TempBitfield, __LINE__) = BitField; \
        Ar.SerializeBits(&PREPROCESSOR_JOIN(TempBitfield, __LINE__), 1); \
        BitField = PREPROCESSOR_JOIN(TempBitfield, __LINE__); \
    }
 
    virtual void SerializeBits(void* V, int64 LengthBits)
    {
        Serialize(V, (LengthBits + 7) / 8);
 
        if (IsLoading() && (LengthBits % 8) != 0)
        {
            ((uint8*)V)[LengthBits / 8] &= ((1 << (LengthBits & 7)) - 1);
        }
    }
 
    virtual void SerializeInt(uint32& Value, uint32 Max)
    {
        ByteOrderSerialize(Value);
    }
 
    CORE_API virtual void SerializeIntPacked(uint32& Value);
    CORE_API virtual void SerializeIntPacked64(uint64& Value);
 
    virtual void Preload(UObject* Object) { }
 
    FArchiveState& GetArchiveState()
    {
        return ImplicitConv<FArchiveState&>(*this);
    }
 
    const FArchiveState& GetArchiveState() const
    {
        return ImplicitConv<const FArchiveState&>(*this);
    }
 
    using FArchiveState::SetArchiveState;
    using FArchiveState::SetError;
    using FArchiveState::ClearError;
    using FArchiveState::SetCriticalError;
    using FArchiveState::GetInnermostState;
    using FArchiveState::CountBytes;
    using FArchiveState::GetArchiveName;
    using FArchiveState::GetLinker;
    using FArchiveState::Tell;
    using FArchiveState::TotalSize;
    using FArchiveState::AtEnd;
 
    virtual void Seek(int64 InPos) { }
 
    virtual void AttachBulkData(UObject* Owner, FBulkData* BulkData) { }
    virtual void AttachBulkData(UE::Serialization::FEditorBulkData* BulkData) {}
 
    virtual void DetachBulkData(FBulkData* BulkData, bool bEnsureBulkDataIsLoaded) { }
    virtual void DetachBulkData(UE::Serialization::FEditorBulkData* BulkData, bool bEnsureBulkDataIsLoaded) {}
 
    virtual bool SerializeBulkData(FBulkData& BulkData, const FBulkDataSerializationParams& Params)
    { 
        return false;
    }
 
    virtual bool IsProxyOf(FArchive* InOther) const
    {
        return InOther == this;
    }
 
    virtual bool Precache(int64 PrecacheOffset, int64 PrecacheSize)
    {
        return true;
    }
 
    virtual void FlushCache() { }
 
    virtual bool SetCompressionMap(TArray<FCompressedChunk>* CompressedChunks, ECompressionFlags CompressionFlags)
    {
        return false;
    }
 
    virtual void Flush() { }
 
    virtual bool Close()
    {
        return !IsError();
    }
 
    CORE_API void SerializeCompressed(void* V, int64 Length, FName CompressionFormatCannotChange,
        ECompressionFlags Flags=COMPRESS_NoFlags, bool bTreatBufferAsFileReader=false);
    
    CORE_API void SerializeCompressedNew(void* V, int64 Length, FName CompressionFormatToEncode, FName CompressionFormatToDecodeOldV1Files,
        ECompressionFlags Flags=COMPRESS_NoFlags, bool bTreatBufferAsFileReader=false,
        int64 * OutPartialReadLength=nullptr);
        
    CORE_API void SerializeCompressedNew(void* V, int64 Length);
 
 
    using FArchiveState::IsByteSwapping;
 
    CORE_API void ByteSwap(void* V, int32 Length);
 
    inline FArchive& ByteOrderSerialize(void* V, int32 Length)
    {
        if (!IsByteSwapping()) // Most likely case (hot path)
        {
            Serialize(V, Length);
            return *this;
        }
        return SerializeByteOrderSwapped(V, Length); // Slowest and unlikely path (should not be inlined)
    }
 
    using FArchiveState::ThisContainsCode;
    using FArchiveState::ThisContainsMap;
    using FArchiveState::ThisRequiresLocalizationGather;
 
    void StartSerializingDefaults()
    {
        ArSerializingDefaults++;
    }
 
    void StopSerializingDefaults() 
    {
        ArSerializingDefaults--;
    }
 
    virtual void MarkScriptSerializationStart(const UObject* Obj) { }
 
    virtual void MarkScriptSerializationEnd(const UObject* Obj) { }
 
    virtual void MarkSearchableName(const TObjectPtr<const UObject>& TypeObject, const FName& ValueName) const { }
 
    using FArchiveState::GetArchetypeFromLoader;
 
private:
    CORE_API void VARARGS LogfImpl(const TCHAR* Fmt, ...);
 
public:
    // Logf implementation for convenience.
    template <typename FmtType, typename... Types>
    void Logf(const FmtType& Fmt, Types... Args)
    {
        static_assert(TIsArrayOrRefOfTypeByPredicate<FmtType, TIsCharEncodingCompatibleWithTCHAR>::Value, "Formatting string must be a TCHAR array.");
        static_assert((TIsValidVariadicFunctionArg<Types>::Value && ...), "Invalid argument(s) passed to FArchive::Logf");
 
        LogfImpl(Fmt, Args...);
    }
 
    using FArchiveState::UEVer;
    using FArchiveState::LicenseeUEVer;
    using FArchiveState::EngineVer;
    using FArchiveState::EngineNetVer;
    using FArchiveState::GameNetVer;
 
    CORE_API virtual void UsingCustomVersion(const struct FGuid& Guid);
 
    using FArchiveState::CustomVer;
 
    virtual FArchive* GetCacheableArchive()
    {
        return this;
    }
 
    using FArchiveState::IsLoading;
    using FArchiveState::IsLoadingFromCookedPackage;
    using FArchiveState::IsSaving;
    using FArchiveState::IsTransacting;
    using FArchiveState::IsTextFormat;
    using FArchiveState::WantBinaryPropertySerialization;
    using FArchiveState::UseUnversionedPropertySerialization;
    using FArchiveState::IsForcingUnicode;
    using FArchiveState::IsPersistent;
    using FArchiveState::GetError;
    using FArchiveState::IsError;
    using FArchiveState::IsCriticalError;
    using FArchiveState::ContainsCode;
    using FArchiveState::ContainsMap;
    using FArchiveState::RequiresLocalizationGather;
    using FArchiveState::ForceByteSwapping;
    using FArchiveState::IsSerializingDefaults;
    using FArchiveState::IsIgnoringArchetypeRef;
    using FArchiveState::DoDelta;
    using FArchiveState::DoIntraPropertyDelta;
    using FArchiveState::IsIgnoringOuterRef;
    using FArchiveState::IsIgnoringClassGeneratedByRef;
    using FArchiveState::IsIgnoringClassRef;
    using FArchiveState::IsAllowingLazyLoading;
    using FArchiveState::IsObjectReferenceCollector;
    using FArchiveState::IsModifyingWeakAndStrongReferences;
    using FArchiveState::IsCountingMemory;
    using FArchiveState::GetPortFlags;
    using FArchiveState::HasAnyPortFlags;
    using FArchiveState::HasAllPortFlags;
    using FArchiveState::GetDebugSerializationFlags;
    using FArchiveState::ShouldSkipBulkData;
    using FArchiveState::GetMaxSerializeSize;
    using FArchiveState::GetCustomVersions;
    using FArchiveState::SetCustomVersions;
    using FArchiveState::ResetCustomVersions;
    using FArchiveState::SetCustomVersion;
    using FArchiveState::SetByteSwapping;
    using FArchiveState::SetPortFlags;
    using FArchiveState::SetDebugSerializationFlags;
    using FArchiveState::IsFilterEditorOnly;
    using FArchiveState::SetFilterEditorOnly;
    using FArchiveState::IsSavingOptionalObject;
    using FArchiveState::SetSavingOptionalObject;
    using FArchiveState::IsSaveGame;
    using FArchiveState::IsNetArchive;
    using FArchiveState::IsCooking;
    using FArchiveState::CookingTarget;
    UE_DEPRECATED(5.5, "Use SetSavePackageData.")
    void SetCookData(FArchiveCookData* InCookData)
    {
        // Backwards compatibility for this function is not supported because of the low amount of public usage and the
        // cost of supporting the backwards compatability (extra memory on FArchiveSavePackageData). Change your code
        // to use SetSavePackageData, or contact Epic for assistance.
        check(false);
    }
    using FArchiveState::SetSavePackageData;
    using FArchiveState::GetSavePackageData;
    UE_DEPRECATED(5.5, "Use GetCookContext or CookingTarget or GetSavePackageData")
    FArchiveCookData* GetCookData()
    {
        // Backwards compatibility for this function is not supported because of the low amount of public usage and the
        // cost of supporting the backwards compatability (extra memory on FArchiveSavePackageData). Change your code
        // to use GetCookContext or CookingTarget or GetSavePackageData, or contact Epic for assistance.
        check(false);
        return nullptr;
    }
    using FArchiveState::GetCookContext;
    using FArchiveState::UseToResolveEnumerators;
    using FArchiveState::ShouldSkipProperty;
    using FArchiveState::SetSerializedProperty;
    using FArchiveState::GetSerializedProperty;
    using FArchiveState::GetSerializedPropertyChain;
    using FArchiveState::SetSerializedPropertyChain;
 
    CORE_API virtual void PushSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty);
 
    CORE_API virtual void PopSerializedProperty(class FProperty* InProperty, const bool bIsEditorOnlyProperty);
 
#if WITH_EDITORONLY_DATA
    using FArchiveState::IsEditorOnlyPropertyOnTheStack;
#endif
 
    using FArchiveState::SetSerializeContext;
    using FArchiveState::GetSerializeContext;
 
    virtual bool AttachExternalReadDependency(FExternalReadCallback& ReadCallback) { return false; }
 
 
#if USE_STABLE_LOCALIZATION_KEYS
    using FArchiveState::SetLocalizationNamespace;
    using FArchiveState::GetLocalizationNamespace;
#endif // USE_STABLE_LOCALIZATION_KEYS
 
    using FArchiveState::Reset;
 
public:
#if DEVIRTUALIZE_FLinkerLoad_Serialize
    template<SIZE_T Size>
    inline bool FastPathLoad(void* InDest)
    {
        const uint8* RESTRICT Src = ActiveFPLB->StartFastPathLoadBuffer;
        if (Src + Size <= ActiveFPLB->EndFastPathLoadBuffer)
        {
            if constexpr (Size == 2)
            {
                uint16 * RESTRICT Dest = (uint16 * RESTRICT)InDest;
                *Dest = FPlatformMemory::ReadUnaligned<uint16>(Src);
            }
            else if constexpr (Size == 4)
            {
                uint32 * RESTRICT Dest = (uint32 * RESTRICT)InDest;
                *Dest = FPlatformMemory::ReadUnaligned<uint32>(Src);
            }
            else if constexpr (Size == 8)
            {
                uint64 * RESTRICT Dest = (uint64 * RESTRICT)InDest;
                *Dest = FPlatformMemory::ReadUnaligned<uint64>(Src);
            }
            else
            {
                uint8 * RESTRICT Dest = (uint8 * RESTRICT)InDest;
                for (SIZE_T Index = 0; Index < Size; Index++)
                {
                    Dest[Index] = Src[Index];
                }
            }
            ActiveFPLB->StartFastPathLoadBuffer += Size;
            return true;
        }
        return false;
    }
 
    //@todoio FArchive is really a horrible class and the way it is proxied by FLinkerLoad is double terrible. It makes the fast path really hacky and slower than it would need to be.
    using FArchiveState::ActiveFPLB;
    using FArchiveState::InlineFPLB;
 
#else
    template<SIZE_T Size>
    UE_FORCEINLINE_HINT bool FastPathLoad(void* InDest)
    {
        return false;
    }
#endif
 
private:
    // Used internally only to control the amount of generated code/type under control.
    template<typename T>
    FArchive& ByteOrderSerialize(T& Value)
    {
        static_assert(!TIsSigned<T>::Value, "To reduce the number of template instances, cast 'Value' to a uint16&, uint32& or uint64& prior to the call or use ByteOrderSerialize(void*, int32).");
 
        if (!IsByteSwapping()) // Most likely case (hot path)
        {
            Serialize(&Value, sizeof(T));
            return *this;
        }
        return SerializeByteOrderSwapped(Value); // Slowest and unlikely path (but fastest than SerializeByteOrderSwapped(void*, int32)).
    }
 
    // Not inlined to keep ByteOrderSerialize(), small and fast.
    CORE_API FArchive& SerializeByteOrderSwapped(void* V, int32 Length);
    CORE_API FArchive& SerializeByteOrderSwapped(uint16& Value);
    CORE_API FArchive& SerializeByteOrderSwapped(uint32& Value);
    CORE_API FArchive& SerializeByteOrderSwapped(uint64& Value);
#if PLATFORM_COMPILER_DISTINGUISHES_INT_AND_LONG
    FArchive& SerializeByteOrderSwapped(unsigned long& Value)
    {
        static_assert(sizeof(unsigned long) == sizeof(uint64), "Wrong unsigned long size assuption.");
        return SerializeByteOrderSwapped(reinterpret_cast<uint64&>(Value));
    }
#endif
 
private:
    using FArchiveState::ArIsLoading;
    using FArchiveState::ArIsLoadingFromCookedPackage;
    using FArchiveState::ArIsSaving;
    using FArchiveState::ArIsTransacting;
    using FArchiveState::ArIsTextFormat;
    using FArchiveState::ArWantBinaryPropertySerialization;
    using FArchiveState::ArUseUnversionedPropertySerialization;
    using FArchiveState::ArForceUnicode;
    using FArchiveState::ArIsPersistent;
 
public:
    using FArchiveState::ArIsError;
    using FArchiveState::ArIsCriticalError;
    using FArchiveState::ArContainsCode;
    using FArchiveState::ArContainsMap;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    using FArchiveState::ArRequiresLocalizationGather;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    using FArchiveState::ArForceByteSwapping;
    using FArchiveState::ArIgnoreArchetypeRef;
    using FArchiveState::ArNoDelta;
    using FArchiveState::ArNoIntraPropertyDelta;
    using FArchiveState::ArIgnoreOuterRef;
    using FArchiveState::ArIgnoreClassGeneratedByRef;
    using FArchiveState::ArIgnoreClassRef;
    using FArchiveState::ArAllowLazyLoading;
    using FArchiveState::ArIsObjectReferenceCollector;
    using FArchiveState::ArIsModifyingWeakAndStrongReferences;
    using FArchiveState::ArIsCountingMemory;
    using FArchiveState::ArShouldSkipBulkData;
    using FArchiveState::ArIsFilterEditorOnly;
    using FArchiveState::ArIsSavingOptionalObject;
    using FArchiveState::ArIsSaveGame;
    using FArchiveState::ArIsNetArchive;
    using FArchiveState::ArUseCustomPropertyList;
    using FArchiveState::ArSerializingDefaults;
    using FArchiveState::ArPortFlags;
    using FArchiveState::ArMaxSerializeSize;
    using FArchiveState::ArMergeOverrides;
    using FArchiveState::ArPreserveArrayElements;
 
public:
    using FArchiveState::SetIsLoading;
    using FArchiveState::SetIsLoadingFromCookedPackage;
    using FArchiveState::SetIsSaving;
    using FArchiveState::SetIsTransacting;
    using FArchiveState::SetIsTextFormat;
    using FArchiveState::SetWantBinaryPropertySerialization;
    using FArchiveState::SetUseUnversionedPropertySerialization;
    using FArchiveState::SetForceUnicode;
    using FArchiveState::SetIsPersistent;
    using FArchiveState::SetUEVer;
    using FArchiveState::SetLicenseeUEVer;
    using FArchiveState::SetEngineVer;
    using FArchiveState::SetEngineNetVer;
    using FArchiveState::SetGameNetVer;
    using FArchiveState::ShouldSkipCompilingAssets;
    using FArchiveState::SetShouldSkipUpdateCustomVersion;
    using FArchiveState::ShouldSkipUpdateCustomVersion;
    using FArchiveState::SetMigratingRemoteObjects;
    using FArchiveState::IsMigratingRemoteObjects;
    using FArchiveState::GetMigrationContext;
 
    
private:
    using FArchiveState::ArUEVer;
    using FArchiveState::ArLicenseeUEVer;
    using FArchiveState::ArEngineVer;
    using FArchiveState::CustomVersionContainer;
protected:
    using FArchiveState::SetShouldSkipCompilingAssets;
public:
    using FArchiveState::ArCustomPropertyList;
 
    class FScopeSetDebugSerializationFlags
    {
    private:
#if WITH_EDITOR
        uint32 PreviousFlags;
        FArchive& Ar;
#endif
    public:
#if WITH_EDITOR
        FScopeSetDebugSerializationFlags(FArchive& InAr, uint32 NewFlags, bool Remove = false)
            : Ar(InAr)
        {
 
            PreviousFlags = Ar.GetDebugSerializationFlags();
            if (Remove)
            {
                Ar.SetDebugSerializationFlags( PreviousFlags & ~NewFlags);
            }
            else
            {
                Ar.SetDebugSerializationFlags( PreviousFlags | NewFlags);
            }
 
        }
        ~FScopeSetDebugSerializationFlags()
        {
 
            Ar.SetDebugSerializationFlags( PreviousFlags);
        }
#else
        FScopeSetDebugSerializationFlags(FArchive& InAr, uint32 NewFlags, bool Remove = false)
        {}
        ~FScopeSetDebugSerializationFlags()
        {}
#endif
    };
 
#if WITH_EDITOR
    using FArchiveState::ArDebugSerializationFlags;
    
    CORE_API virtual void PushDebugDataString(const FName& DebugData);
    virtual void PopDebugDataString() { }
 
    class FScopeAddDebugData
    {
    private:
        FArchive& Ar;
    public:
        CORE_API FScopeAddDebugData(FArchive& InAr, const FName& DebugData);
 
        ~FScopeAddDebugData()
        {
            Ar.PopDebugDataString();
        }
    };
#endif
 
    class FScopeSeekTo
    {
    public:
        FScopeSeekTo(FArchive& InAr, int64 InPos)
            : Ar(InAr)
            , SavedPos(InAr.Tell())
        {
            Ar.Seek(InPos);
        }
        
        ~FScopeSeekTo()
        {
            Ar.Seek(SavedPos);
        }
 
        FScopeSeekTo(const FScopeSeekTo&) = delete;
        FScopeSeekTo& operator=(const FScopeSeekTo&) = delete;
 
    private:
        FArchive& Ar;
        int64 SavedPos;
    };
 
    virtual void PushFileRegionType(EFileRegionType Type) { }
    virtual void PopFileRegionType() { }
 
private:
    using FArchiveState::SerializedProperty;
 
    using FArchiveState::SerializedPropertyChain;
 
#if USE_STABLE_LOCALIZATION_KEYS
    using FArchiveState::LocalizationNamespacePtr;
#endif // USE_STABLE_LOCALIZATION_KEYS
 
    using FArchiveState::bCustomVersionsAreReset;
};
 
 
 
 
template<class T> T Arctor(FArchive& Ar)
{
    T Tmp;
    Ar << Tmp;
 
    return Tmp;
}
 
template<class TEnum>
inline FArchive& operator<<(FArchive& Ar, TEnumAsByte<TEnum>& Value)
{
#if DEVIRTUALIZE_FLinkerLoad_Serialize
    if (!Ar.FastPathLoad<sizeof(Value)>(&Value))
#endif
    {
        Ar.Serialize(&Value, 1);
    }
    return Ar;
}
 
template <
    typename EnumType,
    std::enable_if_t<TIsEnumClass<EnumType>::Value, int> = 0
>
UE_FORCEINLINE_HINT FArchive& operator<<(FArchive& Ar, EnumType& Value)
{
    return Ar << (__underlying_type(EnumType)&)Value;
}