GCObject.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    GCObject.h: Abstract base class to allow non-UObject objects reference
                UObject instances with proper handling of them by the
                Garbage Collector.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Concepts/DerivedFrom.h"
#include "Traits/IsTriviallyRelocatable.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/ObjectPtr.h"
 
#include "GCObject.generated.h"
 
class FGCObject;
 
UCLASS(Transient, MinimalAPI)
class UGCObjectReferencer : public UObject
{
    struct FImpl;
    TUniquePtr<FImpl> Impl;
 
    FGCObject* CurrentlySerializingObject = nullptr;
 
    friend struct FReplaceReferenceHelper;
 
public:
    GENERATED_BODY()
 
    COREUOBJECT_API UGCObjectReferencer(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    COREUOBJECT_API UGCObjectReferencer(FVTableHelper& Helper);
    COREUOBJECT_API ~UGCObjectReferencer();
 
    COREUOBJECT_API void AddObject(FGCObject* Object);
 
    COREUOBJECT_API void RemoveObject(FGCObject* Object);
 
    COREUOBJECT_API bool GetReferencerName(UObject* Object, FString& OutName, bool bOnlyIfAddingReferenced = false) const;
 
    COREUOBJECT_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    void AddInitialReferences(TArray<UObject**>& Out);
    virtual void FinishDestroy() override;
 
    FGCObject* GetCurrentlySerializingObject() const
    {
        return CurrentlySerializingObject;
    }
 
#if WITH_EDITORONLY_DATA
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FGCObjectAddedDelegate, FGCObject*);
 
private:
 
    FGCObjectAddedDelegate OnGCObjectAdded;
 
public:
 
    FGCObjectAddedDelegate& GetGCObjectAddedDelegate()
    {
        return OnGCObjectAdded;
    }
#endif // WITH_EDITORONLY_DATA
};
 
 
class FGCObject
{
public:
    static COREUOBJECT_API UGCObjectReferencer* GGCObjectReferencer;
 
    static COREUOBJECT_API void StaticInit();
 
    FGCObject()
    {
        RegisterGCObject();
    }
 
    FGCObject(const FGCObject& Other)
    {
        RegisterGCObject();
    }
 
    FGCObject(FGCObject&& Other)
    {
        RegisterGCObject();
    }
 
    enum class EFlags : uint32
    {
        None = 0,
 
        RegisterLater = 1 << 0,
 
        AddStableNativeReferencesOnly = 1 << 1,
    };
    explicit FGCObject(EFlags Flags);
 
    virtual ~FGCObject()
    {
        UnregisterGCObject();
    }
 
    FGCObject& operator=(const FGCObject&) {return *this;}
    FGCObject& operator=(FGCObject&&) {return *this;}
 
    COREUOBJECT_API void RegisterGCObject();
 
    COREUOBJECT_API void UnregisterGCObject();
 
    virtual void AddReferencedObjects( FReferenceCollector& Collector ) = 0;
 
    virtual FString GetReferencerName() const = 0;
 
    virtual bool GetReferencerPropertyName(UObject* Object, FString& OutPropertyName) const
    {
        return false;
    }
 
private:
    friend UGCObjectReferencer;
    static COREUOBJECT_API const TCHAR* UnknownGCObjectName;
 
    const bool bCanMakeInitialReferences = false;
    bool bReferenceAdded = false;   
};
 
ENUM_CLASS_FLAGS(FGCObject::EFlags);
 
inline FGCObject::FGCObject(EFlags Flags)
: bCanMakeInitialReferences(EnumHasAllFlags(Flags, EFlags::AddStableNativeReferencesOnly))
{
    if (!EnumHasAnyFlags(Flags, EFlags::RegisterLater))
    {
        RegisterGCObject();
    }
}
 
// Types derived from FGCObject are not trivially relocatable, so flag their use in containers and other contexts.
template <UE::CDerivedFrom<FGCObject> T>
struct TIsTriviallyRelocatable<T>
{
    static inline constexpr bool Value = false;
};