TransactionCommon.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "UObject/ObjectPtr.h"
#include "UObject/WeakObjectPtr.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/ArchiveSerializedPropertyChain.h"
#include "Templates/TypeHash.h"
#include "Misc/TransactionObjectEvent.h"
#include "Containers/SortedMap.h"
 
class FReferenceCollector;
 
namespace UE::Transaction
{
 
struct FPersistentObjectRef
{
public:
    FPersistentObjectRef() = default;
    ENGINE_API explicit FPersistentObjectRef(UObject* InObject);
 
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FPersistentObjectRef& ReferencedObject)
    {
        Ar << (std::underlying_type_t<EReferenceType>&)ReferencedObject.ReferenceType;
        Ar << ReferencedObject.RootObject;
        Ar << ReferencedObject.SubObjectHierarchyIDs;
        return Ar;
    }
 
    friend bool operator==(const FPersistentObjectRef& LHS, const FPersistentObjectRef& RHS)
    {
        return LHS.ReferenceType == RHS.ReferenceType
            && LHS.RootObject == RHS.RootObject
            && (LHS.ReferenceType != EReferenceType::SubObject || LHS.SubObjectHierarchyIDs == RHS.SubObjectHierarchyIDs);
    }
 
    friend bool operator!=(const FPersistentObjectRef& LHS, const FPersistentObjectRef& RHS)
    {
        return !(LHS == RHS);
    }
 
    friend uint32 GetTypeHash(const FPersistentObjectRef& InObjRef)
    {
        return HashCombine(::GetTypeHash(InObjRef.ReferenceType), GetTypeHash(InObjRef.RootObject));
    }
 
    bool IsRootObjectReference() const
    {
        return ReferenceType == EReferenceType::RootObject;
    }
 
    bool IsSubObjectReference() const
    {
        return ReferenceType == EReferenceType::SubObject;
    }
 
    ENGINE_API UObject* Get() const;
    
    ENGINE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
private:
    enum class EReferenceType : uint8
    {
        Unknown,
        RootObject,
        SubObject,
    };
 
    EReferenceType ReferenceType = EReferenceType::Unknown;
    TObjectPtr<UObject> RootObject = nullptr;
    TArray<FName, TInlineAllocator<4>> SubObjectHierarchyIDs;
 
    mutable TWeakObjectPtr<UObject> CachedRootObject;
    mutable TArray<TWeakObjectPtr<UObject>, TInlineAllocator<4>> CachedSubObjectHierarchy;
};
 
struct FSerializedTaggedData
{
public:
    static ENGINE_API FSerializedTaggedData FromOffsetAndSize(const int64 InOffset, const int64 InSize);
    static ENGINE_API FSerializedTaggedData FromStartAndEnd(const int64 InStart, const int64 InEnd);
 
    ENGINE_API void AppendSerializedData(const int64 InOffset, const int64 InSize);
    ENGINE_API void AppendSerializedData(const FSerializedTaggedData& InData);
 
    ENGINE_API bool HasSerializedData() const;
 
    int64 GetStart() const
    {
        return DataOffset;
    }
 
    int64 GetEnd() const
    {
        return DataOffset + DataSize;
    }
 
    friend bool operator==(const FSerializedTaggedData& LHS, const FSerializedTaggedData& RHS)
    {
        return LHS.DataOffset == RHS.DataOffset
            && LHS.DataSize == RHS.DataSize;
    }
 
    friend bool operator!=(const FSerializedTaggedData& LHS, const FSerializedTaggedData& RHS)
    {
        return !(LHS == RHS);
    }
 
    int64 DataOffset = INDEX_NONE;
 
    int64 DataSize = 0;
};
 
struct FSerializedObjectData
{
public:
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FSerializedObjectData& SerializedData)
    {
        Ar << SerializedData.Data;
        return Ar;
    }
 
    friend bool operator==(const FSerializedObjectData& LHS, const FSerializedObjectData& RHS)
    {
        return LHS.Data == RHS.Data;
    }
 
    friend bool operator!=(const FSerializedObjectData& LHS, const FSerializedObjectData& RHS)
    {
        return !(LHS == RHS);
    }
 
    ENGINE_API void Read(void* Dest, int64 Offset, int64 Num) const;
    ENGINE_API void Write(const void* Src, int64 Offset, int64 Num);
    
    const void* GetPtr(int64 Offset) const
    {
        return &Data[Offset];
    }
 
    void Reset()
    {
        Data.Reset();
    }
 
    int64 Num() const
    {
        return Data.Num();
    }
 
private:
    TArray64<uint8> Data;
};
 
struct FSerializedObjectInfo : public FTransactionObjectId
{
public:
    FSerializedObjectInfo() = default;
 
    explicit FSerializedObjectInfo(const UObject* InObject)
    {
        SetObject(InObject);
    }
 
    void SetObject(const UObject* InObject)
    {
        FTransactionObjectId::SetObject(InObject);
        bIsPendingKill = !IsValid(InObject);
    }
 
    void Reset()
    {
        FTransactionObjectId::Reset();
        bIsPendingKill = false;
    }
 
    void Swap(FSerializedObjectInfo& Other)
    {
        FTransactionObjectId::Swap(Other);
        Exchange(bIsPendingKill, Other.bIsPendingKill);
    }
 
    bool bIsPendingKill = false;
};
 
struct FSerializedObject
{
public:
    void Reset()
    {
        SerializedData.Reset();
        ReferencedObjects.Reset();
        ReferencedNames.Reset();
    }
 
    void Swap(FSerializedObject& Other)
    {
        Exchange(SerializedData, Other.SerializedData);
        Exchange(ReferencedObjects, Other.ReferencedObjects);
        Exchange(ReferencedNames, Other.ReferencedNames);
    }
 
    FSerializedObjectData SerializedData;
 
    TArray<FPersistentObjectRef> ReferencedObjects;
    
    TArray<FName> ReferencedNames;
};
 
struct FDiffableObject
{
public:
    void SetObject(const UObject* InObject)
    {
        ObjectInfo.SetObject(InObject);
        ObjectArchetype = FPersistentObjectRef(InObject->GetArchetype());
        ObjectFlags = InObject->GetFlags();
    }
 
    void Reset()
    {
        ObjectInfo.Reset();
        ObjectArchetype = FPersistentObjectRef();
        ObjectFlags = RF_NoFlags;
        SerializedData.Reset();
        SerializedTaggedData.Reset();
    }
 
    void Swap(FDiffableObject& Other)
    {
        ObjectInfo.Swap(Other.ObjectInfo);
        Exchange(ObjectArchetype, Other.ObjectArchetype);
        Exchange(ObjectFlags, Other.ObjectFlags);
        Exchange(SerializedData, Other.SerializedData);
        Exchange(SerializedTaggedData, Other.SerializedTaggedData);
    }
 
    FSerializedObjectInfo ObjectInfo;
 
    FPersistentObjectRef ObjectArchetype;
 
    EObjectFlags ObjectFlags = RF_NoFlags;
 
    FSerializedObjectData SerializedData;
 
    TSortedMap<FName, FSerializedTaggedData, FDefaultAllocator, FNameFastLess> SerializedTaggedData;
};
 
ENGINE_API extern const FName TaggedDataKey_UnknownData;
ENGINE_API extern const FName TaggedDataKey_ScriptData;
 
class FSerializedObjectDataReader : public FArchiveUObject
{
public:
    ENGINE_API FSerializedObjectDataReader(const FSerializedObject& InSerializedObject);
 
    virtual int64 Tell() override { return Offset; }
    virtual void Seek(int64 InPos) override { Offset = InPos; }
    virtual int64 TotalSize() override { return SerializedObject.SerializedData.Num(); }
 
protected:
    ENGINE_API virtual void Serialize(void* SerData, int64 Num) override;
 
    using FArchiveUObject::operator<<;
    ENGINE_API virtual FArchive& operator<<(class FName& N) override;
    ENGINE_API virtual FArchive& operator<<(class UObject*& Res) override;
 
    const FSerializedObject& SerializedObject;
    int64 Offset = 0;
};
 
namespace Internal
{
 
class FSerializedObjectDataWriterCommon : public FArchiveUObject
{
public:
    ENGINE_API FSerializedObjectDataWriterCommon(FSerializedObjectData& InSerializedData);
 
    virtual int64 Tell() override { return Offset; }
    virtual void Seek(int64 InPos) override { checkSlow(Offset <= SerializedData.Num()); Offset = InPos; }
    virtual int64 TotalSize() override { return SerializedData.Num(); }
 
protected:
    ENGINE_API virtual void Serialize(void* SerData, int64 Num) override;
 
    virtual void OnDataSerialized(int64 InOffset, int64 InNum) {}
 
    FSerializedObjectData& SerializedData;
    int64 Offset = 0;
};
 
} // namespace Internal
 
class FSerializedObjectDataWriter : public Internal::FSerializedObjectDataWriterCommon
{
public:
    ENGINE_API FSerializedObjectDataWriter(FSerializedObject& InSerializedObject);
 
protected:
    using FArchiveUObject::operator<<;
    ENGINE_API virtual FArchive& operator<<(class FName& N) override;
    ENGINE_API virtual FArchive& operator<<(class UObject*& Res) override;
 
    FSerializedObject& SerializedObject;
    int64 Offset = 0;
 
    TMap<UObject*, int32> ObjectMap;
    TMap<FName, int32> NameMap;
};
 
class FDiffableObjectDataWriter : public Internal::FSerializedObjectDataWriterCommon
{
public:
    ENGINE_API FDiffableObjectDataWriter(FDiffableObject& InDiffableObject, TArrayView<const FProperty*> InPropertiesToSerialize = TArrayView<const FProperty*>());
 
protected:
    ENGINE_API FName GetTaggedDataKey() const;
 
    ENGINE_API bool DoesObjectMatchDiffableObject(const UObject* Obj) const;
 
    ENGINE_API virtual bool ShouldSkipProperty(const FProperty* InProperty) const override;
 
    ENGINE_API virtual void MarkScriptSerializationStart(const UObject* Obj) override;
    ENGINE_API virtual void MarkScriptSerializationEnd(const UObject* Obj) override;
 
    ENGINE_API virtual void OnDataSerialized(int64 InOffset, int64 InNum) override;
 
    using FArchiveUObject::operator<<;
    ENGINE_API virtual FArchive& operator<<(class FName& N) override;
    ENGINE_API virtual FArchive& operator<<(class UObject*& Res) override;
 
private:
    struct FCachedPropertyKey
    {
    public:
        FName SyncCache(const FArchiveSerializedPropertyChain& InPropertyChain);
 
    private:
        FName CachedKey;
        uint32 LastUpdateCount = 0;
    };
 
    struct FCachedTaggedDataEntry
    {
    public:
        FSerializedTaggedData& SyncCache(FDiffableObject& InDiffableObject, const FName InSerializedTaggedDataKey);
 
    private:
        FName CachedKey;
        FSerializedTaggedData* CachedEntryPtr = nullptr;
    };
 
    FDiffableObject& DiffableObject;
    TArrayView<const FProperty*> PropertiesToSerialize;
 
    bool bIsPerformingScriptSerialization = false;
 
    mutable bool bWasUsingTaggedDataKey_UnknownData = false;
    mutable bool bWasUsingTaggedDataKey_ScriptData = false;
    mutable int32 TaggedDataKeyIndex_UnknownData = 0;
    mutable int32 TaggedDataKeyIndex_ScriptData = 0;
    mutable FCachedPropertyKey CachedSerializedTaggedPropertyKey;
    mutable FCachedTaggedDataEntry CachedSerializedTaggedDataEntry;
};
 
namespace DiffUtil
{
ENGINE_API bool IsGeneratingDiffableObject(const FArchive& Ar);
 
enum class EGetDiffableObjectMode : uint8
{
    SerializeObject,
 
    SerializeProperties,
 
    Custom,
};
 
struct FGetDiffableObjectOptions
{
    EGetDiffableObjectMode ObjectSerializationMode = EGetDiffableObjectMode::SerializeObject;
 
    TFunction<void(FDiffableObjectDataWriter&)> CustomSerializer;
 
    TArrayView<const FProperty*> PropertiesToSerialize;
 
    bool bSerializeEvenIfPendingKill = false;
};
 
ENGINE_API FDiffableObject GetDiffableObject(const UObject* Object, const FGetDiffableObjectOptions& Options = FGetDiffableObjectOptions());
 
struct FGenerateObjectDiffOptions
{
    FGenerateObjectDiffOptions()
    {
        ArchetypeOptions.bSerializeEvenIfPendingKill = true;
    }
 
    FGetDiffableObjectOptions ArchetypeOptions;
 
    TFunction<bool(FName)> ShouldSkipProperty;
 
    bool bFullDiff = true;
 
    bool bDiffDataEvenIfPendingKill = false;
};
 
class FDiffableObjectArchetypeCache
{
public:
    const FDiffableObject& GetArchetypeDiffableObject(const UObject* Archetype, const FGetDiffableObjectOptions& Options);
 
private:
    TMap<const UObject*, FDiffableObject> ArchetypeDiffableObjects;
};
 
ENGINE_API FTransactionObjectDeltaChange GenerateObjectDiff(const FDiffableObject& OldDiffableObject, const FDiffableObject& NewDiffableObject, const FGenerateObjectDiffOptions& DiffOptions = FGenerateObjectDiffOptions(), FDiffableObjectArchetypeCache* ArchetypeCache = nullptr);
ENGINE_API void GenerateObjectDiff(const FDiffableObject& OldDiffableObject, const FDiffableObject& NewDiffableObject, FTransactionObjectDeltaChange& OutDeltaChange, const FGenerateObjectDiffOptions& DiffOptions = FGenerateObjectDiffOptions(), FDiffableObjectArchetypeCache* ArchetypeCache = nullptr);
 
} // namespace DiffUtil
 
} // namespace UE::Transaction