// Copyright Epic Games, Inc. All Rights Reserved.

#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Templates/Casts.h"
#include "UObject/UnrealType.h"
#include "UObject/UnrealTypePrivate.h"
#include "UObject/UObjectHash.h"
#include "Blueprint/BlueprintSupport.h"
#include "UObject/PropertyHelper.h"
#include "UObject/LinkerPlaceholderClass.h"
#include "UObject/LinkerPlaceholderExportObject.h"
#include "Misc/StringBuilder.h"

// WARNING: This should always be the last include in any file that needs it (except .generated.h)
#include "UObject/UndefineUPropertyMacros.h"

/*-----------------------------------------------------------------------------
        FObjectPropertyBase.
-----------------------------------------------------------------------------*/
IMPLEMENT_FIELD(FObjectPropertyBase)

#if WITH_EDITORONLY_DATA
FObjectPropertyBase::FObjectPropertyBase(UField* InField)
    : FProperty(InField)
{
    UObjectPropertyBase* SourceProperty = CastChecked<UObjectPropertyBase>(InField);
    PropertyClass                       = SourceProperty->PropertyClass;
}
#endif  // WITH_EDITORONLY_DATA

void FObjectPropertyBase::BeginDestroy()
{
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    if (ULinkerPlaceholderClass* PlaceholderClass = Cast<ULinkerPlaceholderClass>(PropertyClass))
    {
        PlaceholderClass->RemoveReferencingProperty(this);
    }
#endif  // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING

    Super::BeginDestroy();
}

void FObjectPropertyBase::InstanceSubobjects(void* Data, void const* DefaultData, UObject* InOwner, FObjectInstancingGraph* InstanceGraph)
{
    for (int32 ArrayIndex = 0; ArrayIndex < ArrayDim; ArrayIndex++)
    {
        UObject* CurrentValue = GetObjectPropertyValue((uint8*)Data + ArrayIndex * ElementSize);
        if (CurrentValue)
        {
            UObject* SubobjectTemplate = DefaultData ? GetObjectPropertyValue((uint8*)DefaultData + ArrayIndex * ElementSize) : nullptr;
            UObject* NewValue          = InstanceGraph->InstancePropertyValue(SubobjectTemplate, CurrentValue, InOwner, HasAnyPropertyFlags(CPF_Transient), HasAnyPropertyFlags(CPF_InstancedReference));
            SetObjectPropertyValue((uint8*)Data + ArrayIndex * ElementSize, NewValue);
        }
    }
}

bool FObjectPropertyBase::Identical(const void* A, const void* B, uint32 PortFlags) const
{
    UObject* ObjectA = A ? GetObjectPropertyValue(A) : nullptr;
    UObject* ObjectB = B ? GetObjectPropertyValue(B) : nullptr;
    if (!ObjectA && !ObjectB)
    {
        return true;
    }
    if (!ObjectA || !ObjectB)
    {
        return false;
    }
    // Compare actual pointers. We don't do this during PIE because we want to be sure to serialize everything. An example is the LevelScriptActor being serialized against its CDO,
    // which contains actor references. We want to serialize those references so they are fixed up.
    const bool bDuplicatingForPIE = (PortFlags & PPF_DuplicateForPIE) != 0;
    bool bResult                  = !bDuplicatingForPIE ? (ObjectA == ObjectB) : false;
    // always serialize the cross level references, because they could be nullptr
    // @todo: okay, this is pretty hacky overall - we should have a PortFlag or something
    // that is set during SavePackage. Other times, we don't want to immediately return false
    // (instead of just this ExportDefProps case)

    // In order for a deep comparison of instanced objects to match both objects must have the same class and name
    if (!bResult && ObjectA->GetClass() == ObjectB->GetClass() && ObjectA->GetFName() == ObjectB->GetFName())
    {
        bool bPerformDeepComparison = (PortFlags & PPF_DeepComparison) != 0;
        if (((PortFlags & PPF_DeepCompareInstances) != 0) && !bPerformDeepComparison)
        {
            bPerformDeepComparison = !(ObjectA->IsTemplate() && ObjectB->IsTemplate());
        }

        if (bPerformDeepComparison)
        {
            if ((PortFlags & PPF_DeepCompareDSOsOnly) != 0)
            {
                if (UObject* DSO = ObjectA->GetClass()->GetDefaultSubobjectByName(ObjectA->GetFName()))
                {
                    checkSlow(ObjectA->IsDefaultSubobject() && ObjectB->IsDefaultSubobject() && DSO == ObjectB->GetClass()->GetDefaultSubobjectByName(ObjectB->GetFName()));
                }
                else
                {
                    bPerformDeepComparison = false;
                }
            }

            if (bPerformDeepComparison)
            {
                bResult = AreInstancedObjectsIdentical(ObjectA, ObjectB, PortFlags);
            }
        }
    }
    return bResult;
}

bool FObjectPropertyBase::NetSerializeItem(FArchive& Ar, UPackageMap* Map, void* Data, TArray<uint8>* MetaData) const
{
    UObject* Object = GetObjectPropertyValue(Data);
    bool Result     = Map->SerializeObject(Ar, PropertyClass, Object);
    SetObjectPropertyValue(Data, Object);
    return Result;
}
void FObjectPropertyBase::Serialize(FArchive& Ar)
{
    Super::Serialize(Ar);
    Ar << PropertyClass;

#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    if (Ar.IsLoading() || Ar.IsObjectReferenceCollector())
    {
        if (ULinkerPlaceholderClass* PlaceholderClass = Cast<ULinkerPlaceholderClass>(PropertyClass))
        {
            PlaceholderClass->AddReferencingProperty(this);
        }
    }
#endif  // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
}

void FObjectPropertyBase::PostDuplicate(const FField& InField)
{
    const FObjectPropertyBase& Source = static_cast<const FObjectPropertyBase&>(InField);
    PropertyClass                     = Source.PropertyClass;
    Super::PostDuplicate(InField);
}

#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
void FObjectPropertyBase::SetPropertyClass(UClass* NewPropertyClass)
{
    if (ULinkerPlaceholderClass* NewPlaceholderClass = Cast<ULinkerPlaceholderClass>(NewPropertyClass))
    {
        NewPlaceholderClass->AddReferencingProperty(this);
    }

    if (ULinkerPlaceholderClass* OldPlaceholderClass = Cast<ULinkerPlaceholderClass>(PropertyClass))
    {
        OldPlaceholderClass->RemoveReferencingProperty(this);
    }
    PropertyClass = NewPropertyClass;
}
#endif  // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING

void FObjectPropertyBase::AddReferencedObjects(FReferenceCollector& Collector)
{
    Collector.AddReferencedObject(PropertyClass);
    Super::AddReferencedObjects(Collector);
}

FString FObjectPropertyBase::GetExportPath(const UObject* Object, const UObject* Parent, const UObject* ExportRootScope, const uint32 PortFlags)
{
    bool bExportFullyQualified = true;

    // When exporting from one package or graph to another package or graph, we don't want to fully qualify the name, as it may refer
    // to a level or graph that doesn't exist or cause a linkage to a node in a different graph
    const UObject* StopOuter = nullptr;
    if (PortFlags & PPF_ExportsNotFullyQualified)
    {
        StopOuter             = (ExportRootScope || (Parent == nullptr)) ? ExportRootScope : Parent->GetOutermost();
        bExportFullyQualified = StopOuter && !Object->IsIn(StopOuter);

        // Also don't fully qualify the name if it's a sibling of the root scope, since it may be included in the exported set of objects
        if (bExportFullyQualified)
        {
            StopOuter             = StopOuter->GetOuter();
            bExportFullyQualified = (StopOuter == nullptr) || (!Object->IsIn(StopOuter));
        }
    }

    // if we want a full qualified object reference, use the pathname, otherwise, use just the object name
    if (bExportFullyQualified)
    {
        StopOuter = nullptr;
        if ((PortFlags & PPF_SimpleObjectText) != 0 && Parent != nullptr)
        {
            StopOuter = Parent->GetOutermost();
        }
    }
    else if (Parent != nullptr && Object->IsIn(Parent))
    {
        StopOuter = Parent;
    }

    // Take the path name relative to the stopping point outermost ptr.
    // This is so that cases like a component referencing a component in another actor work correctly when pasted
    FString PathName = Object->GetPathName(StopOuter);
    int32 ResultIdx  = 0;
    // Object names that contain invalid characters and paths that contain spaces must be put into quotes to be handled correctly
    if (PortFlags & PPF_Delimited)
    {
        PathName = FString::Printf(TEXT("\"%s\""), *PathName.ReplaceQuotesWithEscapedQuotes());
    }
    return FString::Printf(TEXT("%s'%s'"), *Object->GetClass()->GetName(), *PathName);
}

void FObjectPropertyBase::ExportTextItem(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const
{
    UObject* Temp = GetObjectPropertyValue(PropertyValue);

    if (0 != (PortFlags & PPF_ExportCpp))
    {
        ValueStr += Temp ? FString::Printf(TEXT("LoadObject<%s%s>(nullptr, TEXT(\"%s\"))"), PropertyClass->GetPrefixCPP(), *PropertyClass->GetName(), *(Temp->GetPathName().ReplaceCharWithEscapedChar())) : TEXT("nullptr");
        return;
    }

    if (Temp != nullptr)
    {
        if (PortFlags & PPF_DebugDump)
        {
            ValueStr += Temp->GetFullName();
        }
        else if (Parent && !Parent->HasAnyFlags(RF_ClassDefaultObject) && Temp->IsDefaultSubobject())
        {
            if (PortFlags & PPF_Delimited)
            {
                ValueStr += FString::Printf(TEXT("\"%s\""), *Temp->GetName().ReplaceQuotesWithEscapedQuotes());
            }
            else
            {
                ValueStr += Temp->GetName();
            }
        }
        else
        {
            ValueStr += GetExportPath(Temp, Parent, ExportRootScope, PortFlags);
        }
    }
    else
    {
        ValueStr += TEXT("None");
    }
}

/**
 * Parses a text buffer into an object reference.
 *
 * @param	Property			the property that the value is being importing to
 * @param	OwnerObject			the object that is importing the value; used for determining search scope.
 * @param	RequiredMetaClass	the meta-class for the object to find; if the object that is resolved is not of this class type, the result is nullptr.
 * @param	PortFlags			bitmask of EPropertyPortFlags that can modify the behavior of the search
 * @param	Buffer				the text to parse; should point to a textual representation of an object reference.  Can be just the object name (either fully
 *								fully qualified or not), or can be formatted as a const object reference (i.e. SomeClass'SomePackage.TheObject')
 *								When the function returns, Buffer will be pointing to the first character after the object value text in the input stream.
 * @param	ResolvedValue		receives the object that is resolved from the input text.
 *
 * @return	true if the text is successfully resolved into a valid object reference of the correct type, false otherwise.
 */
bool FObjectPropertyBase::ParseObjectPropertyValue(const FProperty* Property, UObject* OwnerObject, UClass* RequiredMetaClass, uint32 PortFlags, const TCHAR*& Buffer, UObject*& out_ResolvedValue, FUObjectSerializeContext* InSerializeContext /*= nullptr*/, bool bAllowAnyPackage /*= true*/)
{
    check(Property);
    if (!RequiredMetaClass)
    {
        UE_LOG(LogProperty, Error, TEXT("ParseObjectPropertyValue Error: RequiredMetaClass is null, for property: %s "), *Property->GetFullName());
        out_ResolvedValue = nullptr;
        return false;
    }

    const TCHAR* InBuffer = Buffer;

    TStringBuilder<256> Temp;
    Buffer = FPropertyHelpers::ReadToken(Buffer, /* out */ Temp, true);
    if (Buffer == nullptr)
    {
        return false;
    }

    if (Temp == TEXT("None"_SV))
    {
        out_ResolvedValue = nullptr;
    }
    else
    {
        UClass* ObjectClass = RequiredMetaClass;

        SkipWhitespace(Buffer);

        bool bWarnOnnullptr = (PortFlags & PPF_CheckReferences) != 0;

        if (*Buffer == TCHAR('\''))
        {
            Temp.Reset();
            Buffer = FPropertyHelpers::ReadToken(++Buffer, /* out */ Temp, true);
            if (Buffer == nullptr)
            {
                return false;
            }

            if (*Buffer++ != TCHAR('\''))
            {
                return false;
            }

            // ignore the object class, it isn't fully qualified, and searching ANY_PACKAGE might get the wrong one!
            // Try the find the object.
            out_ResolvedValue = FObjectPropertyBase::FindImportedObject(Property, OwnerObject, ObjectClass, RequiredMetaClass, Temp.ToString(), PortFlags, InSerializeContext, bAllowAnyPackage);
        }
        else
        {
            // Try the find the object.
            out_ResolvedValue = FObjectPropertyBase::FindImportedObject(Property, OwnerObject, ObjectClass, RequiredMetaClass, Temp.ToString(), PortFlags, InSerializeContext, bAllowAnyPackage);
        }

        if (out_ResolvedValue != nullptr && !out_ResolvedValue->GetClass()->IsChildOf(RequiredMetaClass))
        {
            if (bWarnOnnullptr)
            {
                UE_LOG(LogProperty, Error, TEXT("%s: bad cast in '%s'"), *Property->GetFullName(), InBuffer);
            }

            out_ResolvedValue = nullptr;
            return false;
        }

        // If we couldn't find it or load it, we'll have to do without it.
        if (out_ResolvedValue == nullptr)
        {
            if (bWarnOnnullptr)
            {
                UE_LOG(LogProperty, Warning, TEXT("%s: unresolved reference to '%s'"), *Property->GetFullName(), InBuffer);
            }
            return false;
        }
    }

    return true;
}

const TCHAR* FObjectPropertyBase::ImportText_Internal(const TCHAR* InBuffer, void* Data, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText) const
{
    const TCHAR* Buffer = InBuffer;
    UObject* Result     = nullptr;
    FLinkerLoad* Linker = GetLinker();

    bool bOk            = ParseObjectPropertyValue(this, Parent, PropertyClass, PortFlags, Buffer, Result, Linker ? Linker->GetSerializeContext() : nullptr);

    if (Result && (PortFlags & PPF_InstanceSubobjects) != 0 && HasAnyPropertyFlags(CPF_InstancedReference))
    {
        FName DesiredName = Result->GetFName();

        // If an object currently exists with the same name as the imported object that is to be instanced
        //
        if (UObject* ExistingObject = static_cast<UObject*>(FindObjectWithOuter(Parent, nullptr, DesiredName)))
        {
            ExistingObject->Rename(nullptr, nullptr, REN_DontCreateRedirectors | REN_ForceNoResetLoaders);
        }

        Result = DuplicateObject<UObject>(Result, Parent, DesiredName);
        if (Parent->IsTemplate())
        {
            Result->SetFlags(RF_ArchetypeObject);
        }
        else
        {
            Result->ClearFlags(RF_ArchetypeObject);
        }
    }

    SetObjectPropertyValue(Data, Result);
    return Buffer;
}

UObject* FObjectPropertyBase::FindImportedObject(const FProperty* Property, UObject* OwnerObject, UClass* ObjectClass, UClass* RequiredMetaClass, const TCHAR* Text, uint32 PortFlags /*=0*/, FUObjectSerializeContext* InSerializeContext /*= nullptr*/, bool bAllowAnyPackage /*= true*/)
{
    UObject* Result = nullptr;
    check(ObjectClass->IsChildOf(RequiredMetaClass));

    bool AttemptNonQualifiedSearch = (PortFlags & PPF_AttemptNonQualifiedSearch) != 0;

    // if we are importing default properties, first look for a matching subobject by
    // looking through the archetype chain at each outer and stop once the outer chain reaches the owning class's default object
    if (PortFlags & PPF_ParsingDefaultProperties)
    {
        for (UObject* SearchStart = OwnerObject; Result == nullptr && SearchStart != nullptr; SearchStart = SearchStart->GetOuter())
        {
            UObject* ScopedSearchRoot = SearchStart;
            while (Result == nullptr && ScopedSearchRoot != nullptr)
            {
                Result = StaticFindObjectSafe(ObjectClass, ScopedSearchRoot, Text);
                // don't think it's possible to get a non-subobject here, but it doesn't hurt to check
                if (Result != nullptr && !Result->IsTemplate(RF_ClassDefaultObject))
                {
                    Result = nullptr;
                }

                ScopedSearchRoot = ScopedSearchRoot->GetArchetype();
            }
            if (SearchStart->HasAnyFlags(RF_ClassDefaultObject))
            {
                break;
            }
        }
    }

    // if we have a parent, look in the parent, then it's outer, then it's outer, ...
    // this is because exported object properties that point to objects in the level aren't
    // fully qualified, and this will step up the nested object chain to solve any name
    // collisions within a nested object tree
    UObject* ScopedSearchRoot = OwnerObject;
    while (Result == nullptr && ScopedSearchRoot != nullptr)
    {
        Result = StaticFindObjectSafe(ObjectClass, ScopedSearchRoot, Text);
        // disallow class default subobjects here while importing defaults
        // this prevents the use of a subobject name that doesn't exist in the scope of the default object being imported
        // from grabbing some other subobject with the same name and class in some other arbitrary default object
        if (Result != nullptr && (PortFlags & PPF_ParsingDefaultProperties) && Result->IsTemplate(RF_ClassDefaultObject))
        {
            Result = nullptr;
        }

        ScopedSearchRoot = ScopedSearchRoot->GetOuter();
    }

    if (Result == nullptr)
    {
        // attempt to find a fully qualified object
        Result = StaticFindObjectSafe(ObjectClass, nullptr, Text);

        if (Result == nullptr && (PortFlags & PPF_SerializedAsImportText))
        {
            // Check string asset redirectors
            FSoftObjectPath Path(Text);
            if (Path.PreSavePath())
            {
                Result = StaticFindObjectSafe(ObjectClass, nullptr, *Path.ToString());
            }
        }

        if (Result == nullptr && bAllowAnyPackage)
        {
            // match any object of the correct class who shares the same name regardless of package path
            Result = StaticFindObjectSafe(ObjectClass, ANY_PACKAGE, Text);
            // disallow class default subobjects here while importing defaults
            if (Result != nullptr && (PortFlags & PPF_ParsingDefaultProperties) && Result->IsTemplate(RF_ClassDefaultObject))
            {
                Result = nullptr;
            }
        }
    }

    // if we haven;t found it yet, then try to find it without a qualified name
    if (!Result)
    {
        const TCHAR* Dot = FCString::Strrchr(Text, '.');
        if (Dot && AttemptNonQualifiedSearch)
        {
            // search with just the object name
            Result = FindImportedObject(Property, OwnerObject, ObjectClass, RequiredMetaClass, Dot + 1, 0);
        }
        FString NewText(Text);
        // if it didn't have a dot, then maybe they just gave a uasset package name
        if (!Dot && !Result)
        {
            int32 LastSlash = NewText.Find(TEXT("/"), ESearchCase::CaseSensitive, ESearchDir::FromEnd);
            if (LastSlash >= 0)
            {
                NewText += TEXT(".");
                NewText += (Text + LastSlash + 1);
                Dot = FCString::Strrchr(*NewText, '.');
            }
        }
        // If we still can't find it, try to load it. (Only try to load fully qualified names)
        if (!Result && Dot && !GIsSavingPackage)
        {
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
            FLinkerLoad* Linker = (OwnerObject != nullptr) ? OwnerObject->GetClass()->GetLinker() : nullptr;
            if (Linker == nullptr)
            {
                // Fall back on the Properties owner. That is probably the thing that has triggered this load:
                Linker = Property->GetLinker();
            }
            const bool bDeferAssetImports = (Linker != nullptr) && (Linker->LoadFlags & LOAD_DeferDependencyLoads);

            if (bDeferAssetImports)
            {
                Result = Linker->RequestPlaceholderValue(ObjectClass, Text);
            }

            if (Result == nullptr)
#endif  // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
            {
                const uint32 LoadFlags = LOAD_NoWarn | LOAD_FindIfFail;

                UE_LOG(LogProperty, Verbose, TEXT("FindImportedObject is attempting to import [%s] (class = %s) with StaticLoadObject"), Text, *GetFullNameSafe(ObjectClass));
                Result = StaticLoadObject(ObjectClass, nullptr, Text, nullptr, LoadFlags, nullptr, true);

#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
                check(!bDeferAssetImports || !Result || !FBlueprintSupport::IsInBlueprintPackage(Result));
#endif  // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
            }
        }
    }

    // if we found an object, and we have a parent, make sure we are in the same package or share an outer if the found object is private, unless it's a cross level property
    if (Result && !Result->HasAnyFlags(RF_Public) && OwnerObject && Result->GetOutermostObject() != OwnerObject->GetOutermostObject() && Result->GetPackage() != OwnerObject->GetPackage())
    {
        const FObjectPropertyBase* ObjectProperty = CastField<const FObjectPropertyBase>(Property);
        if (!ObjectProperty || !ObjectProperty->AllowCrossLevel())
        {
            UE_LOG(LogProperty, Warning, TEXT("Illegal TEXT reference to a private object in external package (%s) from referencer (%s).  Import failed..."), *Result->GetFullName(), *OwnerObject->GetFullName());
            Result = nullptr;
        }
    }

    check(!Result || Result->IsA(RequiredMetaClass));
    return Result;
}

FName FObjectPropertyBase::GetID() const
{
    return NAME_ObjectProperty;
}

UObject* FObjectPropertyBase::GetObjectPropertyValue(const void* PropertyValueAddress) const
{
    check(0);
    return nullptr;
}

void FObjectPropertyBase::SetObjectPropertyValue(void* PropertyValueAddress, UObject* Value) const
{
    check(0);
}

bool FObjectPropertyBase::AllowCrossLevel() const
{
    return false;
}

void FObjectPropertyBase::CheckValidObject(void* Value) const
{
    UObject* Object = GetObjectPropertyValue(Value);
    if (Object)
    {
        //
        // here we want to make sure the the object value still matches the
        // object type expected by the property...

        UClass* ObjectClass = Object->GetClass();
        UE_CLOG(!ObjectClass, LogProperty, Fatal, TEXT("Object without class referenced by %s, object: 0x%016llx %s"), *GetPathName(), (int64)(PTRINT)Object, *Object->GetPathName());

        // we could be in the middle of replacing references to the
        // PropertyClass itself (in the middle of an FArchiveReplaceObjectRef
        // pass)... if this is the case, then we might have already replaced
        // the object's class, but not the PropertyClass yet (or vise-versa)...
        // so we use this to ensure, in that situation, that we don't clear the
        // object value (if CLASS_NewerVersionExists is set, then we are likely
        // in the middle of an FArchiveReplaceObjectRef pass)
        bool bIsReplacingClassRefs = PropertyClass && PropertyClass->HasAnyClassFlags(CLASS_NewerVersionExists) != ObjectClass->HasAnyClassFlags(CLASS_NewerVersionExists);

#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
        FLinkerLoad* PropertyLinker      = GetLinker();
        bool const bIsDeferringValueLoad = ((PropertyLinker == nullptr) || (PropertyLinker->LoadFlags & LOAD_DeferDependencyLoads)) &&
                                           (Object->IsA<ULinkerPlaceholderExportObject>() || Object->IsA<ULinkerPlaceholderClass>());

#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
        check(bIsDeferringValueLoad || (!Object->IsA<ULinkerPlaceholderExportObject>() && !Object->IsA<ULinkerPlaceholderClass>()));
#endif  // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS

#else   // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
        bool const bIsDeferringValueLoad = false;
#endif  // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING

        if ((PropertyClass != nullptr) && !ObjectClass->IsChildOf(PropertyClass) && !ObjectClass->GetAuthoritativeClass()->IsChildOf(PropertyClass) && !bIsReplacingClassRefs && !bIsDeferringValueLoad)
        {
            UE_LOG(LogProperty, Warning,
                   TEXT("Serialized %s for a property of %s. Reference will be nullptred.\n    Property = %s\n    Item = %s"),
                   *Object->GetClass()->GetFullName(),
                   *PropertyClass->GetFullName(),
                   *GetFullName(),
                   *Object->GetFullName());
            SetObjectPropertyValue(Value, nullptr);
        }
    }
}

bool FObjectPropertyBase::SameType(const FProperty* Other) const
{
    return Super::SameType(Other) && (PropertyClass == ((FObjectPropertyBase*)Other)->PropertyClass);
}

void FObjectPropertyBase::CopySingleValueToScriptVM(void* Dest, void const* Src) const
{
    *(UObject**)Dest = GetObjectPropertyValue(Src);
}

void FObjectPropertyBase::CopyCompleteValueToScriptVM(void* Dest, void const* Src) const
{
    for (int32 Index = 0; Index < ArrayDim; Index++)
    {
        ((UObject**)Dest)[Index] = GetObjectPropertyValue(((uint8*)Src) + Index * ElementSize);
    }
}

void FObjectPropertyBase::CopySingleValueFromScriptVM(void* Dest, void const* Src) const
{
    SetObjectPropertyValue(Dest, *(UObject**)Src);
}

void FObjectPropertyBase::CopyCompleteValueFromScriptVM(void* Dest, void const* Src) const
{
    checkSlow(ElementSize == sizeof(UObject*));  // the idea that script pointers are the same size as weak pointers is maybe required, maybe not
    for (int32 Index = 0; Index < ArrayDim; Index++)
    {
        SetObjectPropertyValue(((uint8*)Dest) + Index * ElementSize, ((UObject**)Src)[Index]);
    }
}

#include "UObject/DefineUPropertyMacros.h"