MemberReference.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "Templates/SubclassOf.h"
#include "UObject/UnrealType.h"
#include "UObject/Package.h"
#include "UObject/UObjectIterator.h"
#include "Engine/Blueprint.h"
#include "EngineLogs.h"
#include "MemberReference.generated.h"
 
struct FFieldRemapInfo
{
    FName FieldName;
 
    FName FieldClass;
 
    bool operator==(const FFieldRemapInfo& Other) const
    {
        return FieldName == Other.FieldName && FieldClass == Other.FieldClass;
    }
 
    friend uint32 GetTypeHash(const FFieldRemapInfo& RemapInfo)
    {
        return GetTypeHash(RemapInfo.FieldName) + GetTypeHash(RemapInfo.FieldClass) * 23;
    }
 
    FFieldRemapInfo()
        : FieldName(NAME_None)
        , FieldClass(NAME_None)
    {
    }
};
 
struct FParamRemapInfo
{
    bool    bCustomValueMapping;
    FName   OldParam;
    FName   NewParam;
    FName   NodeTitle;
    TMap<FString, FString> ParamValueMap;
 
    // constructor
    FParamRemapInfo()
        : OldParam(NAME_None)
        , NewParam(NAME_None)
        , NodeTitle(NAME_None)
    {
    }
};
 
// @TODO: this can encapsulate globally defined fields as well (like with native 
//        delegate signatures); consider renaming to FFieldReference
USTRUCT()
struct FMemberReference
{
    GENERATED_USTRUCT_BODY()
 
protected:
    UPROPERTY(SaveGame)
    mutable TObjectPtr<UObject> MemberParent;
 
    UPROPERTY(SaveGame)
    mutable FString MemberScope;
 
    UPROPERTY(SaveGame)
    mutable FName MemberName;
 
    UPROPERTY(SaveGame)
    mutable FGuid MemberGuid;
 
    UPROPERTY(SaveGame)
    mutable bool bSelfContext;
 
    UPROPERTY(SaveGame)
    mutable bool bWasDeprecated;
    
public:
    FMemberReference()
        : MemberParent(nullptr)
        , MemberName(NAME_None)
        , bSelfContext(false)
        , bWasDeprecated(false)
    {
    }
 
    template<class TFieldType>
    void SetFromField(const typename TFieldType::BaseFieldClass* InField, const bool bIsConsideredSelfContext, UClass* OwnerClass=nullptr)
    {
        // if we didn't get an owner passed in try to figure out what it should be based on the field
        if (!OwnerClass)
        {
            OwnerClass = InField->GetOwnerClass();
        }
        MemberParent = OwnerClass;
 
        if (bIsConsideredSelfContext)
        {
            MemberParent = nullptr;
        }
        else if ((MemberParent == nullptr) && InField->GetName().EndsWith(HEADER_GENERATED_DELEGATE_SIGNATURE_SUFFIX))
        {
            MemberParent = InField->GetOutermost();
        }
 
        MemberName = InField->GetFName();
        bSelfContext = bIsConsideredSelfContext;
        bWasDeprecated = false;
 
#if WITH_EDITOR
        if (UClass* ParentAsClass = GetMemberParentClass())
        {
            MemberParent = ParentAsClass->GetAuthoritativeClass();
        }
#endif
 
        MemberGuid.Invalidate();
        if (OwnerClass != nullptr)
        {
            UBlueprint::GetGuidFromClassByFieldName<TFieldType>(OwnerClass, InField->GetFName(), MemberGuid);
        }
    }
 
#if WITH_EDITOR
    template<class TFieldType>
    void SetFromField(const typename TFieldType::BaseFieldClass* InField, UClass* SelfScope)
    {
        UClass* OwnerClass = InField->GetOwnerClass();
 
        FGuid FieldGuid;
        if (OwnerClass != nullptr)
        {
            UBlueprint::GetGuidFromClassByFieldName<TFieldType>(OwnerClass, InField->GetFName(), FieldGuid);
        }
 
        SetGivenSelfScope(InField->GetFName(), FieldGuid, OwnerClass, SelfScope);
    }
 
    template<class TFieldType>
    void RefreshGivenNewSelfScope(UClass* SelfScope)
    {
        UClass* ParentAsClass = GetMemberParentClass();
        if ((ParentAsClass != nullptr) && (SelfScope != nullptr))
        {
            UBlueprint::GetGuidFromClassByFieldName<TFieldType>((ParentAsClass), MemberName, MemberGuid);
            SetGivenSelfScope(MemberName, MemberGuid, ParentAsClass, SelfScope);
        }
        else
        {
            // We no longer have enough information to known if we've done the right thing, and just have to hope...
        }
    }
#endif
 
    ENGINE_API void SetExternalMember(FName InMemberName, TSubclassOf<class UObject> InMemberParentClass);
    ENGINE_API void SetExternalMember(FName InMemberName, TSubclassOf<class UObject> InMemberParentClass, const FGuid& InMemberGuid);
 
    ENGINE_API void SetGlobalField(FName InFieldName, UPackage* InParentPackage);
 
    ENGINE_API void SetExternalDelegateMember(FName InMemberName);
 
    ENGINE_API void SetSelfMember(FName InMemberName);
    ENGINE_API void SetSelfMember(FName InMemberName, const FGuid& InMemberGuid);
 
    ENGINE_API void SetLocalMember(FName InMemberName, UStruct* InScope, const FGuid InMemberGuid);
 
    ENGINE_API void SetLocalMember(FName InMemberName, FString InScopeName, const FGuid InMemberGuid);
 
    ENGINE_API void SetDirect(const FName InMemberName, const FGuid InMemberGuid, TSubclassOf<class UObject> InMemberParentClass, bool bIsConsideredSelfContext);
 
    ENGINE_API void InvalidateScope();
 
    FName GetMemberName() const
    {
        return MemberName;
    }
 
#if WITH_EDITOR
    void SetMemberName(FName NewName)
    {
        MemberName = NewName;
    }
#endif
 
    FGuid GetMemberGuid() const
    {
        return MemberGuid;
    }
 
    UClass* GetMemberParentClass() const
    {
        return Cast<UClass>(MemberParent);
    }
 
    UPackage* GetMemberParentPackage() const
    {
        if (UPackage* ParentAsPackage = Cast<UPackage>(MemberParent))
        {
            return ParentAsPackage;
        }
        else if (MemberParent != nullptr)
        {
            return MemberParent->GetOutermost();
        }
        return nullptr;
    }
 
    bool IsSelfContext() const
    {
        return bSelfContext;
    }
 
    bool IsLocalScope() const
    {
        return !MemberScope.IsEmpty();
    }
 
    ENGINE_API bool IsSparseClassData(const UClass* OwningClass) const;
 
#if WITH_EDITOR
    ENGINE_API FString GetReferenceSearchString(UClass* InFieldOwner) const;
#endif
 
private:
#if WITH_EDITOR
    ENGINE_API FName RefreshLocalVariableName(UClass* InSelfScope) const;
#endif
 
protected:
#if WITH_EDITOR
    ENGINE_API void SetGivenSelfScope(const FName InMemberName, const FGuid InMemberGuid, TSubclassOf<class UObject> InMemberParentClass, TSubclassOf<class UObject> SelfScope) const;
#endif
public:
 
    UClass* GetMemberParentClass(UClass* SelfScope) const
    {
        // Local variables with a MemberScope act much the same as being SelfContext, their parent class is SelfScope.
        return (bSelfContext || !MemberScope.IsEmpty())? SelfScope : GetMemberParentClass();
    }
 
    UStruct* GetMemberScope(UClass* InMemberParentClass) const
    {
        return FindUField<UStruct>(InMemberParentClass, *MemberScope);
    }
 
    FString GetMemberScopeName() const
    {
        return MemberScope;
    }
 
    bool IsSameReference(const FMemberReference& InReference) const
    {
        return 
            bSelfContext == InReference.bSelfContext &&
            MemberParent == InReference.MemberParent &&
            MemberName == InReference.MemberName &&
            MemberGuid == InReference.MemberGuid &&
            MemberScope == InReference.MemberScope;
    }
 
    bool IsDeprecated() const
    {
        return bWasDeprecated;
    }
 
    UClass* GetScope(UClass* SelfScope = nullptr) const
    {
        return bSelfContext ? SelfScope : GetMemberParentClass();
    }
 
    template<class TFieldType>
    TFieldType* ResolveMember(UClass* SelfScope = nullptr, const bool bAlwaysFollowRedirects = false) const
    {
        return static_cast<TFieldType*>(ResolveMemberProperty(SelfScope, bAlwaysFollowRedirects, TFieldType::StaticClass()));
    }
    template<>
    UFunction* ResolveMember(UClass* SelfScope, const bool bAlwaysFollowRedirects) const
    {
        return ResolveMemberFunction(SelfScope, bAlwaysFollowRedirects);
    }
 
    template<class TFieldType>
    TFieldType* ResolveMember(UBlueprint* SelfScope)
    {
        return ResolveMember<TFieldType>(SelfScope->SkeletonGeneratedClass);
    }
 
    ENGINE_API static UField* FindRemappedField(UClass *FieldClass, UClass* InitialScope, FName InitialName,
        bool bInitialScopeMustBeOwnerOfFieldForParentScopeRedirect = false);
    ENGINE_API static FField* FindRemappedField(FFieldClass* FieldClass, UClass* InitialScope, FName InitialName,
        bool bInitialScopeMustBeOwnerOfFieldForParentScopeRedirect = false);
 
    template<class TFieldType>
    static TFieldType* FindRemappedField(UClass* InitialScope, FName InitialName,
        bool bInitialScopeMustBeOwnerOfFieldForParentScopeRedirect = false)
    {
        return FFieldVariant(FindRemappedField(TFieldType::StaticClass(), InitialScope, InitialName,
            bInitialScopeMustBeOwnerOfFieldForParentScopeRedirect)).Get<TFieldType>();
    }
 
#if WITH_EDITOR
    ENGINE_API static void InitFieldRedirectMap();
 
protected:
 
    static bool bFieldRedirectMapInitialized;
    
    ENGINE_API static UClass* GetClassToUse(UClass* InClass, bool bUseUpToDateClass);
#endif
    template<class TFieldType, class TFieldTypeClass>
    TFieldType* ResolveMemberImpl(UClass* SelfScope, TFieldTypeClass* FieldClas, const bool bAlwaysFollowRedirects, const bool bIsUFunctionOrMulticastDelegate) const;
 
    ENGINE_API FProperty* ResolveMemberProperty(UClass* SelfScope, const bool bAlwaysFollowRedirects, FFieldClass* FieldClass) const;
    ENGINE_API UFunction* ResolveMemberFunction(UClass* SelfScope, const bool bAlwaysFollowRedirects) const;
 
public:
    template<class TFieldType>
    static void FillSimpleMemberReference(const TFieldType* InField, FSimpleMemberReference& OutReference)
    {
        OutReference.Reset();
 
        if (InField)
        {
            FMemberReference TempMemberReference;
            TempMemberReference.SetFromField<TFieldType>(InField, false);
 
            OutReference.MemberName = TempMemberReference.MemberName;
            OutReference.MemberParent = TempMemberReference.MemberParent;
            OutReference.MemberGuid = TempMemberReference.MemberGuid;
        }
    }
 
    template<class TFieldType>
    static TFieldType* ResolveSimpleMemberReference(const FSimpleMemberReference& Reference, UClass* SelfScope = nullptr)
    {
        FMemberReference TempMemberReference;
 
        const FName Name = Reference.MemberGuid.IsValid() ? NAME_None : Reference.MemberName; // if the guid is valid don't check the name, it could be renamed 
        TempMemberReference.MemberName   = Name;
        TempMemberReference.MemberGuid   = Reference.MemberGuid;
        TempMemberReference.MemberParent = Reference.MemberParent;
 
        auto Result = TempMemberReference.ResolveMember<TFieldType>(SelfScope);
        if (!Result && (Name != Reference.MemberName))
        {
            TempMemberReference.MemberName = Reference.MemberName;
            Result = TempMemberReference.ResolveMember<TFieldType>(SelfScope);
        }
 
        return Result;
    }
};