OverriddenPropertySet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
 
#include "OverriddenPropertySet.generated.h"
 
#define UE_API COREUOBJECT_API
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogOverridableObject, Warning, All);
 
struct FArchiveSerializedPropertyChain;
 
struct FOverridableSerializationLogicInternalAdapter;
/*
 *************************************************************************************
 * Overridable serialization is experimental, not supported and use at your own risk *
 *************************************************************************************
 * Scope responsible to control overridable serialization logic.
 */
struct FOverridableSerializationLogic
{
public:
    
    enum class ECapabilities : uint32
    {
        None = 0,
        // Enables serialization of override state into and from T3D
        T3DSerialization = 1 << 0,
        // Enables shadow serialization of subobject, any saved data can be skipped at load time unless loading in loose property or in a placeholder.
        // This will keep reference to subobjects that might contain overrides.
        SubObjectsShadowSerialization = 1 << 1,
        All = T3DSerialization | SubObjectsShadowSerialization
    };
    
    FRIEND_ENUM_CLASS_FLAGS(FOverridableSerializationLogic::ECapabilities)
 
    
    inline static void Enable(FOverriddenPropertySet* InOverriddenProperties)
    {
        checkf(!bUseOverridableSerialization, TEXT("Nobody should use this method if overridable serialization is already enabled"));
        bUseOverridableSerialization = true;
        OverriddenProperties = InOverriddenProperties;
    }
 
    inline static void Disable()
    {
        checkf(bUseOverridableSerialization, TEXT("Expecting overridable serialization to be already enabled"));
        OverriddenProperties = nullptr;
        bUseOverridableSerialization = false;
    }
 
    inline static bool IsEnabled()
    {
        return bUseOverridableSerialization;
    }
 
    
    COREUOBJECT_API static bool HasCapabilities(ECapabilities InCapabilities);
 
    inline static FOverriddenPropertySet* GetOverriddenProperties()
    {
        return OverriddenProperties;
    }
 
    COREUOBJECT_API static FOverriddenPropertySet* GetOverriddenPropertiesSlow();
 
    COREUOBJECT_API static EOverriddenPropertyOperation GetOverriddenPropertyOperation(const FArchive& Ar, FProperty* Property = nullptr, uint8* DataPtr = nullptr, const uint8* DefaultValue = nullptr);
 
    COREUOBJECT_API static EOverriddenPropertyOperation GetOverriddenPropertyOperationForPortText(const void* DataPtr, const void* DefaultValue, int32 PortFlags);
 
    COREUOBJECT_API static FPropertyVisitorPath* GetOverriddenPortTextPropertyPath();
 
    COREUOBJECT_API static void SetOverriddenPortTextPropertyPath(FPropertyVisitorPath& Path);
 
    COREUOBJECT_API static void ResetOverriddenPortTextPropertyPath();
 
    COREUOBJECT_API static bool ShouldPropertyShadowSerializeSubObject(TNotNull<const FProperty*> Property);
 
private:
 
    static EOverriddenPropertyOperation GetOverriddenPropertyOperation(const int32 PortFlags, const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property, const void* DataPtr, const void* DefaultValue);
 
    friend struct FOverridableSerializationLogicInternalAdapter;
    
    static ECapabilities Capabilities;
    static thread_local bool bUseOverridableSerialization;
    static thread_local FOverriddenPropertySet* OverriddenProperties;
    static thread_local FPropertyVisitorPath* OverriddenPortTextPropertyPath;
};
 
/*
 *************************************************************************************
 * Overridable serialization is experimental, not supported and use at your own risk *
 *************************************************************************************
 * Scope responsible for enabling/disabling the overridable serialization from the parameters
*/
struct FEnableOverridableSerializationScope
{
    COREUOBJECT_API FEnableOverridableSerializationScope(bool bEnableOverridableSerialization, FOverriddenPropertySet* OverriddenProperties);
    COREUOBJECT_API ~FEnableOverridableSerializationScope();
 
protected:
    bool bOverridableSerializationEnabled = false;
    bool bWasOverridableSerializationEnabled = false;
    FOverriddenPropertySet* SavedOverriddenProperties = nullptr;
};
 
 
/*
 *************************************************************************************
 * Overridable serialization is experimental, not supported and use at your own risk *
 *************************************************************************************
 * Scope responsible for tracking current property path for text importing
*/
struct FOverridableTextPortPropertyPathScope
{
    COREUOBJECT_API FOverridableTextPortPropertyPathScope(const FProperty* InProperty, int32 InIndex = INDEX_NONE, EPropertyVisitorInfoType InPropertyInfo = EPropertyVisitorInfoType::None);
    COREUOBJECT_API ~FOverridableTextPortPropertyPathScope();
 
protected:
 
    const FProperty* Property = nullptr;
    FPropertyVisitorPath DefaultPath;
};
 
/*
 * Override operation type for each property node
 */
UENUM()
enum class EOverriddenPropertyOperation : uint8
{
    None =  0,  /* no overridden operation was recorded on this property  */
    Modified,   /* some sub property has recorded overridden operation */
    Replace,    /* everything has been overridden from this property down to every sub property/sub object*/
    Add,        /* this element was added in the container */
    Remove,     /* this element was removed from the container */
    SubObjectsShadowing, /* only used to serialize/collect the subobjects, this saved data can be skipped at loading unless loading a loose property or in a placeholder which will keep reference to subobjects */
};
 
inline TOptional<EOverriddenPropertyOperation> GetOverriddenOperationFromString(const FString& OverriddenOperationString)
{
    int64 EnumValue = StaticEnum<EOverriddenPropertyOperation>()->GetValueByNameString(StaticEnum<EOverriddenPropertyOperation>()->GetName() + FString(TEXT("::")) + OverriddenOperationString);
    if (EnumValue == INDEX_NONE)
    {
        return TOptional<EOverriddenPropertyOperation>();
    }
 
    return TOptional((EOverriddenPropertyOperation)EnumValue);
}
 
inline TOptional<EOverriddenPropertyOperation> GetOverriddenOperationFromName(const FName OverriddenOperationName)
{
    return GetOverriddenOperationFromString(OverriddenOperationName.ToString());
}
 
inline FString GetOverriddenOperationString(EOverriddenPropertyOperation Operation)
{
    return UEnum::GetValueAsString(Operation).RightChop(StaticEnum<EOverriddenPropertyOperation>()->GetName().Len() + /*::*/2);
}
 
USTRUCT()
struct FOverriddenPropertyPath
{
    GENERATED_BODY()
 
    FOverriddenPropertyPath(const FName Name);
 
    FOverriddenPropertyPath() = default;
    FOverriddenPropertyPath(const FOverriddenPropertyPath&) = default;
    FOverriddenPropertyPath(FOverriddenPropertyPath&&) = default;
    FOverriddenPropertyPath& operator=(const FOverriddenPropertyPath&) = default;
    FOverriddenPropertyPath& operator=(FOverriddenPropertyPath&&) = default;
 
    FOverriddenPropertyPath& operator=(const FName Name);
    FOverriddenPropertyPath operator+(const FName Name) const;
    FOverriddenPropertyPath operator+(const FOverriddenPropertyPath& Other) const;
    void operator+=(const FName Name);
    void operator+=(const TArray<FName>& Names);
    void operator+=(const FOverriddenPropertyPath& Other)
    {
        this->operator+=(Other.Path);
    }
 
    bool operator==(const FOverriddenPropertyPath& Other) const
    {
        return CachedHash == Other.CachedHash;
    }
 
    bool IsEmpty() const
    {
        return Path.IsEmpty();
    }
 
    FString ToString() const;
 
private:
    UPROPERTY()
    TArray<FName> Path;
 
    UPROPERTY()
    uint32 CachedHash = 0;
 
    friend uint32 GetTypeHash(const FOverriddenPropertyPath& MappableString)
    {
        return MappableString.CachedHash;
    }
};
 
USTRUCT()
struct FOverriddenPropertyNodeID
{
    GENERATED_BODY()
 
    COREUOBJECT_API FOverriddenPropertyNodeID(TNotNull<const FProperty*> Property);
    COREUOBJECT_API FOverriddenPropertyNodeID(TNotNull<const UObject*> InObject);
    COREUOBJECT_API FOverriddenPropertyNodeID(const FOverriddenPropertyNodeID& ParentNodeID, const FOverriddenPropertyNodeID& SubNodeID);
 
    FOverriddenPropertyNodeID() = default;
    FOverriddenPropertyNodeID(const FOverriddenPropertyNodeID&) = default;
    FOverriddenPropertyNodeID(FOverriddenPropertyNodeID&&) = default;
    FOverriddenPropertyNodeID& operator=(const FOverriddenPropertyNodeID&) = default;
    FOverriddenPropertyNodeID& operator=(FOverriddenPropertyNodeID&&) = default;
 
    static COREUOBJECT_API FOverriddenPropertyNodeID RootNodeId();
 
    // Overridden property node map helpers
    static COREUOBJECT_API FOverriddenPropertyNodeID FromMapKey(const FProperty* KeyProperty, const void* KeyData);
    COREUOBJECT_API int32 ToMapInternalIndex(FScriptMapHelper& MapHelper) const;
 
    COREUOBJECT_API bool operator==(const FOverriddenPropertyNodeID& Other) const;
 
    FString ToString() const
    {
        return Path.ToString();
    }
 
    FString ToDebugString() const
    {
        return Path.ToString() + FString::Printf(TEXT("(0x%p)"), Object.Get());
    }
 
    bool IsValid() const
    {
        return !Path.IsEmpty();
    }
 
    void HandleObjectsReInstantiated(const TMap<UObject*, UObject*>& Map);
    void HandleDeadObjectReferences(const TSet<UObject*>& ActiveInstances, const TSet<UObject*>& TemplateInstances);
 
    friend uint32 GetTypeHash(const FOverriddenPropertyNodeID& NodeID)
    {
        return GetTypeHash(NodeID.Path);
    }
 
private:
    UPROPERTY()
    FOverriddenPropertyPath Path;
 
    UPROPERTY()
    TWeakObjectPtr<const UObject> Object;
};
 
/*
 *************************************************************************************
 * Overridable serialization is experimental, not supported and use at your own risk *
 *************************************************************************************
 * Overridden property information node, there will be one per overriden property/subojects
 *
 */
USTRUCT()
struct FOverriddenPropertyNode
{
    GENERATED_BODY()
 
    FOverriddenPropertyNode() = default;
    FOverriddenPropertyNode(const FOverriddenPropertyNode&) = default;
    FOverriddenPropertyNode(FOverriddenPropertyNode&&) = default;
    FOverriddenPropertyNode& operator=(const FOverriddenPropertyNode&) = default;
    FOverriddenPropertyNode& operator=(FOverriddenPropertyNode&&) = default;
 
    FOverriddenPropertyNode(const FOverriddenPropertyNodeID& InNodeID)
        : NodeID(InNodeID)
    {}
    FOverriddenPropertyNode(FOverriddenPropertyNodeID&& InNodeID)
        : NodeID(MoveTemp(InNodeID))
    {}
 
private:
    UPROPERTY()
    FOverriddenPropertyNodeID NodeID;
 
    UPROPERTY()
    EOverriddenPropertyOperation Operation = EOverriddenPropertyOperation::None;
 
    // Unable to make this a UPROPERTY() because of this UHT error:
    // 'Struct' recursion via arrays is unsupported for properties.
    // Instead will be serializing by hand
    TArray<FOverriddenPropertyNode> SubPropertyNodes;
 
public:
 
    const FOverriddenPropertyNodeID& GetNodeID() const
    {
        return NodeID;
    }
 
    EOverriddenPropertyOperation GetOperation() const
    {
        return Operation;
    }
 
    void SetOperation(EOverriddenPropertyOperation InOperation, bool* bWasModified = nullptr);
 
    TArrayView<FOverriddenPropertyNode> GetSubPropertyNodes()
    {
        return SubPropertyNodes;
    }
 
    const TArray<FOverriddenPropertyNode>& GetSubPropertyNodes() const
    {
        return SubPropertyNodes;
    }
 
    FOverriddenPropertyNode& FindOrAddNode(const FOverriddenPropertyNodeID& NodeID, bool* bWasModified = nullptr);
 
    bool RemoveSubPropertyNode(const FOverriddenPropertyNodeID& NodeID, bool* bWasModified = nullptr);
 
    bool operator==(const FOverriddenPropertyNode& Other) const
    {
        return NodeID == Other.NodeID;
    }
 
    void Reset(bool* bWasModified = nullptr);
 
    void HandleObjectsReInstantiated(const TMap<UObject*, UObject*>& Map);
    void HandleDeadObjectReferences(const TSet<UObject*>& ActiveInstances, const TSet<UObject*>& TemplateInstances);
 
    UE_API bool Serialize(FArchive& Ar);
    friend FArchive& operator<<(FArchive& Ar, FOverriddenPropertyNode& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
};
 
template<>
struct TStructOpsTypeTraits<FOverriddenPropertyNode> : public TStructOpsTypeTraitsBase2<FOverriddenPropertyNode>
{
    enum 
    {
        WithSerializer = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
/*
 * Property change notification type mapping the Pre/PostEditChange callbacks
 */
enum class EPropertyNotificationType : uint8
{
    PreEdit,
    PostEdit
};
 
/*
 *************************************************************************************
 * Overridable serialization is experimental, not supported and use at your own risk *
 *************************************************************************************
 * Structure holding and tracking overridden properties of an UObject
 */
USTRUCT()
struct FOverriddenPropertySet
{
    GENERATED_BODY()
 
public:
 
    FOverriddenPropertySet() = default;
    FOverriddenPropertySet(TNotNull<UObject*> InOwner)
        : Owner(InOwner)
    {}
 
    UE_API EOverriddenPropertyOperation GetOverriddenPropertyOperation(FPropertyVisitorPath::Iterator PropertyIterator, bool* bOutInheritedOperation = nullptr) const;
 
    UE_API bool ClearOverriddenProperty(FPropertyVisitorPath::Iterator PropertyIterator);
 
    UE_API void OverrideProperty(FPropertyVisitorPath::Iterator PropertyIterator, const void* Data);
 
    UE_API void NotifyPropertyChange(const EPropertyNotificationType Notification, FPropertyVisitorPath::Iterator PropertyIterator, const EPropertyChangeType::Type ChangeType, const void* Data);
 
    UE_API EOverriddenPropertyOperation GetOverriddenPropertyOperation(const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property) const;
 
    UE_API FOverriddenPropertyNode* RestoreOverriddenPropertyOperation(EOverriddenPropertyOperation Operation, const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property);
 
    UE_API FOverriddenPropertyNode* ConditionallyRestoreOverriddenPropertyOperation(EOverriddenPropertyOperation Operation, const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property);
 
    UE_API const FOverriddenPropertyNode* GetOverriddenPropertyNode(const FArchiveSerializedPropertyChain* CurrentPropertyChain) const;
    UE_API const FOverriddenPropertyNode* GetOverriddenPropertyNode(const FOverriddenPropertyNodeID& NodeID) const;
 
    UE_API EOverriddenPropertyOperation GetSubPropertyOperation(const FOverriddenPropertyNodeID& NodeID) const;
 
    UE_API FOverriddenPropertyNode* RestoreSubPropertyOperation(EOverriddenPropertyOperation Operation, FOverriddenPropertyNode& Node, const FOverriddenPropertyNodeID& NodeID);
 
    UE_API FOverriddenPropertyNode* RestoreSubObjectOperation(EOverriddenPropertyOperation Operation, FOverriddenPropertyNode& Node, TNotNull<UObject*> SubObject);
    UE_API bool IsCDOOwningProperty(const FProperty& Property) const;
 
    UE_API void Reset(bool bShouldDirtyObject = true);
    UE_API void HandleObjectsReInstantiated(const TMap<UObject*, UObject*>& Map);
    UE_API void HandleDeadObjectReferences(const TSet<UObject*>& ActiveInstances, const TSet<UObject*>& TemplateInstances);
 
    /* return whether this object is considered added or not */
    bool WasAdded() const
    {
        return bWasAdded;
    }
 
    TObjectPtr<UObject> GetOwner() const
    {
        return Owner;
    }
 
    UE_API void RestoreOverriddenState(const FOverriddenPropertySet& FromOverriddenProperties);
 
protected:
 
    UE_API EOverriddenPropertyOperation GetOverriddenPropertyOperation(const FOverriddenPropertyNode* ParentPropertyNode, FPropertyVisitorPath::Iterator PropertyIterator, bool* bOutInheritedOperation, const void* Data) const;
    UE_API bool ClearOverriddenProperty(FOverriddenPropertyNode& ParentPropertyNode, FPropertyVisitorPath::Iterator PropertyIterator, const void* Data);
    UE_API void NotifyPropertyChange(FOverriddenPropertyNode* ParentPropertyNode, const EPropertyNotificationType Notification, FPropertyVisitorPath::Iterator PropertyIterator, const EPropertyChangeType::Type ChangeType, const void* Data, bool& bNeedsCleanup);
    UE_API void NotifyAllPropertyChange(FOverriddenPropertyNode* ParentPropertyNode, const EPropertyNotificationType Notification, const EPropertyChangeType::Type ChangeType, TNotNull<const UStruct*> Struct, const void* Data);
 
    UE_API EOverriddenPropertyOperation GetOverriddenPropertyOperation(const FOverriddenPropertyNode* ParentPropertyNode, const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property) const;
    UE_API FOverriddenPropertyNode* RestoreOverriddenPropertyOperation(EOverriddenPropertyOperation Operation, FOverriddenPropertyNode& ParentPropertyNode, const FArchiveSerializedPropertyChain* CurrentPropertyChain, FProperty* Property);
    UE_API const FOverriddenPropertyNode* GetOverriddenPropertyNode(const FOverriddenPropertyNode& ParentPropertyNode, const FArchiveSerializedPropertyChain* CurrentPropertyChain) const;
 
    UE_API UObject* TryGetInstancedSubObjectValue(const FObjectPropertyBase* FromProperty, const void* ValuePtr) const;
 
private:
    UPROPERTY()
    TObjectPtr<UObject> Owner = nullptr;
 
    UPROPERTY()
    bool bWasAdded = false;
 
    UPROPERTY()
    FOverriddenPropertyNode RootNode { RootNodeID };
 
    static inline FOverriddenPropertyNodeID RootNodeID = FOverriddenPropertyNodeID::RootNodeId();
 
public:
    bool bNeedsSubobjectTemplateInstantiation = false;
};
 
#undef UE_API