PropertyBagRepository.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Containers/Map.h"
#include "Templates/FunctionFwd.h"
#include "UObject/ObjectPtr.h"
 
class UObject;
class FMemoryArchive;
struct FPropertyChangedChainEvent;
 
namespace UE
{
 
#if WITH_EDITORONLY_DATA
 
#if STATS
struct FPropertyBagRepositoryStats
{
    size_t IDOMemoryBytes;
    int32 NumIDOs;
    int32 NumIDOsWithLooseProperties;
    int32 NumPlaceholderTypes;
};
#endif
 
// Singleton class tracking property bag association with objects
class FPropertyBagRepository
{
    struct FPropertyBagAssociationData
    {
        void Destroy();
 
        TObjectPtr<UObject> InstanceDataObject = nullptr;
        bool bNeedsFixup = false;
    };
    // TODO: Make private throughout and extend access permissions here or in wrapper classes? Don't want engine code modifying bags outside of serializers and details panels.
    //friend UObjectBase;
    //friend UStruct;
    friend struct FScopedInstanceDataObjectLoad;
 
private:
    friend class FPropertyBagRepositoryLock;
    mutable FTransactionallySafeCriticalSection CriticalSection;
 
    // Lifetimes/ownership:
    // Managed within UObjectBase and synced with object lifetime. The repo tracks pointers to bags, not the bags themselves.
 
    // TODO: Currently will only exist in editor world, but could tracking per world make some sense for teardown in future? We're relying on object destruction to occur properly to free these up. 
    TMap<const UObject*, FPropertyBagAssociationData> AssociatedData;
    
    TMap<const UObject*, const UObject*> InstanceDataObjectToOwner;
 
    FPropertyBagRepository();
 
public:
    FPropertyBagRepository(const FPropertyBagRepository &) = delete;
    FPropertyBagRepository& operator=(const FPropertyBagRepository&) = delete;
    
    // Singleton accessor
    static COREUOBJECT_API FPropertyBagRepository& Get();
 
    // Reclaim space - TODO: Hook up to GC.
    void ShrinkMaps();
 
    // Future version for reworked InstanceDataObjects - track InstanceDataObject rather than bag (directly):
 
    UObject* CreateInstanceDataObject(UObject* Owner, FArchive& Archive, int64 StartOffset, int64 EndOffset, bool bIsArchetype = false);
 
    // called at the end of postload to copy data from Owner to its IDO
    COREUOBJECT_API void PostLoadInstanceDataObject(const UObject* Owner);
 
    // TODO: Restrict property bag  destruction to within UObject::BeginDestroy() & FPropertyBagProperty destructor.
    // Removes bag, InstanceDataObject, and all associated data for this object.
    void DestroyOuterBag(const UObject* Owner);
 
    COREUOBJECT_API void ReassociateObjects(const TMap<UObject*, UObject*>& ReplacedObjects);
 
    void PostEditChangeChainProperty(UObject* Object, const FPropertyChangedChainEvent& PropertyChangedEvent);
 
    COREUOBJECT_API bool RequiresFixup(const UObject* Object, bool bIncludeOuter = false) const;
    // set the bNeedsFixup flag for this object's IDO to false
    COREUOBJECT_API void MarkAsFixedUp(const UObject* Object = nullptr);
 
    // Accessors
    COREUOBJECT_API bool HasInstanceDataObject(const UObject* Owner) const;
    COREUOBJECT_API UObject* FindInstanceDataObject(const UObject* Owner);
    COREUOBJECT_API const UObject* FindInstanceDataObject(const UObject* Owner) const;
    COREUOBJECT_API void FindNestedInstanceDataObject(const UObject* Owner, bool bRequiresFixupOnly, TFunctionRef<void(UObject*)> Callback);
    UE_INTERNAL void AddReferencedInstanceDataObject(const UObject* Owner, FReferenceCollector& Collector);
 
    COREUOBJECT_API const UObject* FindInstanceForDataObject(const UObject* InstanceDataObject) const;
 
    #if STATS
    UE_INTERNAL void GatherStats(FPropertyBagRepositoryStats& Stats);
    #endif
 
    UE_INTERNAL void DumpIDOs(FOutputDevice& OutputDevice);
    UE_INTERNAL void DumpPropertyBagPlaceholderTypes(FOutputDevice& OutputDevice);
 
    // Placeholder object feature flags; external callers can query a particular subfeature to see if it's enabled.
    // Note: These have CVar counterparts defined in the .cpp file. Add an entry there to also create a toggle switch.
    enum class EPlaceholderObjectFeature : uint8
    {
        ReplaceMissingTypeImportsOnLoad,
        SerializeExportReferencesOnLoad,
        ReplaceMissingReinstancedTypes,
        ReplaceDeadClassInstanceTypes,
    };
 
    // query for whether or not the given struct/class is a placeholder type
    static COREUOBJECT_API bool IsPropertyBagPlaceholderType(const UStruct* Type);
    // query for whether or not the given object was created as a placeholder type
    static COREUOBJECT_API bool IsPropertyBagPlaceholderObject(const UObject* Object);
    // query for whether or not creating property bag placeholder objects should be allowed
    static COREUOBJECT_API bool IsPropertyBagPlaceholderObjectSupportEnabled();
    // query for whether or not a specific property bag placeholder object feature is enabled
    static COREUOBJECT_API bool IsPropertyBagPlaceholderObjectFeatureEnabled(EPlaceholderObjectFeature Feature);
 
    static COREUOBJECT_API UStruct* CreatePropertyBagPlaceholderType(UObject* Outer, UClass* Class, FName Name = NAME_None, EObjectFlags Flags = RF_NoFlags, UStruct* SuperStruct = nullptr);
    template<typename T = UObject>
    static UClass* CreatePropertyBagPlaceholderClass(UObject* Outer, UClass* Class, FName Name = NAME_None, EObjectFlags Flags = RF_NoFlags)
    {
        return Cast<UClass>(CreatePropertyBagPlaceholderType(Outer, Class, Name, Flags, T::StaticClass()));
    }
 
private:
    void Lock() const { CriticalSection.Lock(); }
    void Unlock() const { CriticalSection.Unlock(); }
 
    // Internal functions requiring the repository to be locked before being called
 
    // Delete owner reference and disassociate all data. Returns success.
    bool RemoveAssociationUnsafe(const UObject* Owner);
};
 
#endif // WITH_EDITORONLY_DATA
 
} // UE