LinkerPlaceholderBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Class.h"
#include "UObject/ObjectRedirector.h"
#include "UObject/ObjectResource.h"
#include "UObject/LinkerLoad.h"
#include "UObject/Field.h"
 
FORCEINLINE bool UseCircularDependencyLoadDeferring()
{
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    return !GEventDrivenLoaderEnabled;
#else
    return false;
#endif
}
 
/*******************************************************************************
 * FPlaceholderContainerTracker / FScopedPlaceholderPropertyTracker
 ******************************************************************************/
 
struct FScopedPlaceholderContainerTracker
{
public:
    FScopedPlaceholderContainerTracker(UObject* InPlaceholderContainerCandidate)
    : bEnabled(UseCircularDependencyLoadDeferring())
    {
        if (bEnabled)
        {
            Push(InPlaceholderContainerCandidate);
        }
    }
    ~FScopedPlaceholderContainerTracker()
    {
        if (bEnabled)
        {
            Pop();
        }
    }
 
private:
    const bool bEnabled;
    UObject* PlaceholderReferencerCandidate;
 
    void Push(UObject* InIntermediateProperty);
    void Pop();
};
 
struct FScopedPlaceholderPropertyTracker
{
public:
     FScopedPlaceholderPropertyTracker(FFieldVariant InIntermediateProperty)
         : bEnabled(UseCircularDependencyLoadDeferring())
     {
        if (bEnabled)
        {
            Push(InIntermediateProperty);
        }
     }
    
    ~FScopedPlaceholderPropertyTracker()
    {
        if (bEnabled)
        {
            Pop();
        }
    }
 
private:
    const bool bEnabled;
    FFieldVariant IntermediateProperty;
    
    void Push(FFieldVariant InIntermediateProperty);
    void Pop();
};
 
/*******************************************************************************
 * TLinkerPlaceholderBase<>
 ******************************************************************************/
 
class FLinkerPlaceholderBase
{
public:
    FLinkerPlaceholderBase();
    virtual ~FLinkerPlaceholderBase();
 
    FPackageIndex PackageIndex;
 
    TWeakObjectPtr<const UClass> DeferredObjectType;
 
    bool AddReferencingPropertyValue(FFieldVariant ReferencingProperty, void* DataPtr);
 
    virtual bool HasKnownReferences() const;
 
    virtual int32 ResolveAllPlaceholderReferences(UObject* ReplacementObj);
 
    /* 
     * Sets up the provided placeholder as a subobject of this placeholder.
     */
    void SetupPlaceholderSubobject(ULinkerPlaceholderExportObject* PlaceholderSubobject);
 
    bool IsDeferredSubobject() const {return OwningPlaceholder != nullptr;}
 
    TArray<ULinkerPlaceholderExportObject*>& GetSubobjectPlaceholders() { return PlaceholderSubobjects; }
 
    bool HasBeenFullyResolved() const;
    
    virtual UObject* GetPlaceholderAsUObject()
        PURE_VIRTUAL(FLinkerPlaceholderBase::GetPlaceholderAsUObject, return nullptr;)
 
    bool IsMarkedResolved() const;
 
protected:
    void MarkAsResolved();
 
private:
    int32 ResolvePlaceholderPropertyValues(UObject* ReplacementObj);
    
    bool bResolveWasInvoked;
 
    struct FPlaceholderValuePropertyPath
    {
        FPlaceholderValuePropertyPath(FFieldVariant ReferencingProperty);
 
        bool IsValid() const;
 
        UClass* GetOwnerClass() const;
 
        int32 Resolve(FLinkerPlaceholderBase* Placeholder, UObject* Replacement, UObject* Container) const;
        int32 ResolveRaw(FLinkerPlaceholderBase* Placeholder, UObject* Replacement, void* Container) const;
 
    private:
        TArray<FFieldVariant> PropertyChain;
 
    public:
        friend uint32 GetTypeHash(const FPlaceholderValuePropertyPath& PlaceholderPropertyRef)
        {
            uint32 Hash = 0;
            for (const FFieldVariant& Property : PlaceholderPropertyRef.PropertyChain)
            {
                Hash = HashCombine(Hash, GetTypeHash(Property.GetRawPointer()));
            }
            return Hash;
        }
 
        friend bool operator==(const FPlaceholderValuePropertyPath& Lhs, const FPlaceholderValuePropertyPath& Rhs)
        {
            if (Lhs.PropertyChain.Num() == Rhs.PropertyChain.Num())
            {
                for (int32 PropIndex = 0; PropIndex < Lhs.PropertyChain.Num(); ++PropIndex)
                {
                    if (Lhs.PropertyChain[PropIndex] != Rhs.PropertyChain[PropIndex])
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        };
    };
    friend class FLinkerPlaceholderObjectImpl; // for access to FPlaceholderValuePropertyPath
    typedef TSet<FPlaceholderValuePropertyPath> FReferencingPropertySet;
 
    TMap< TWeakObjectPtr<UObject>, FReferencingPropertySet > ReferencingContainers;
    TMap< void*, FReferencingPropertySet > ReferencingRawContainers;
 
    TArray<ULinkerPlaceholderExportObject*> PlaceholderSubobjects;
    ULinkerPlaceholderExportObject* OwningPlaceholder;
};
 
/*******************************************************************************
 * TLinkerImportPlaceholderBase<>
 ******************************************************************************/
 
template<class PlaceholderType>
class TLinkerImportPlaceholder : public FLinkerPlaceholderBase
{
public:
    // FLinkerPlaceholderBase interface
    virtual bool  HasKnownReferences() const override;
    virtual int32 ResolveAllPlaceholderReferences(UObject* ReplacementObj) override;
    // End FLinkerPlaceholderBase interface
 
    void AddReferencingProperty(FFieldVariant ReferencingProperty);
 
    void RemoveReferencingProperty(FFieldVariant ReferencingProperty);
 
    void AddReferencingScriptExpr(PlaceholderType** ExpressionPtr);
 
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
    void AddChildObject(UObject* Child);
#endif //USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
 
    void AddDerivedFunction(UStruct* DerivedFunctionType);
private:
    int32 ResolvePropertyReferences(PlaceholderType* ReplacementObj);
 
    int32 SpecializedResolvePropertyReferences(PlaceholderType* ReplacementObj);
 
    int32 ResolveScriptReferences(PlaceholderType* ReplacementObj);
 
    TSet<FFieldVariant> ReferencingProperties;
 
    TSet<PlaceholderType**> ReferencingScriptExpressions;
 
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
    TArray<UObject*> ChildObjects;
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
 
    TSet<UStruct*> DerivedFunctions;
};
 
// Templatized implementation
#include "UObject/LinkerPlaceholderBase.inl" // IWYU pragma: export