PropertyStateTracking.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
 
#if WITH_EDITORONLY_DATA
 
#include "Containers/ContainersFwd.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/SharedPointerFwd.h"
#include "UObject/Class.h"
#include "UObject/UnrealType.h"
 
class FBlake3;
class FName;
class FStructuredArchiveRecord;
class UEnum;
class UObject;
class UStruct;
namespace UE { class FPropertyPathNameTree; }
namespace UE { class FPropertyTypeName; }
 
#define UE_API COREUOBJECT_API
 
namespace UE
{
 
template <EPropertyValueFlags Flag>
class TPropertyValueState
{
public:
    inline explicit TPropertyValueState(const UStruct* InStruct, void* InData)
        : Struct(InStruct)
        , Data(InData)
    {
    }
 
    inline explicit TPropertyValueState(UObject* Object)
        : Struct(Object->GetClass())
        , Data(Object)
    {
    }
 
    inline bool ActivateTracking()
    {
        return Struct->ActivateTrackingPropertyValueFlag(Flag, Data);
    }
 
    inline bool IsTracking() const
    {
        return Struct->IsTrackingPropertyValueFlag(Flag, Data);
    }
 
    bool IsSet(const FProperty* Property, int32 ArrayIndex = 0) const
    {
        bool bIsSet = Struct->HasPropertyValueFlag(Flag, Data, Property, ArrayIndex);
 
        // This is a temporary workaround to handle the case of an object reference being
        // garbage collected and set to NULL (see FGarbageEliminationScopeGuard). This if
        // should be removed once the Editor handles the clearing of deleted object references.
        if (bIsSet && (Flag == EPropertyValueFlags::Initialized) && Property->HasAnyPropertyFlags(CPF_NonNullable))
        {
            if (const FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(Property))
            {
                const UObject* PropertyValue = ObjectProperty->LoadObjectPropertyValue_InContainer(Data);
                if (!PropertyValue)
                {
                    bIsSet = false;
                }
            }
        }
        
        return bIsSet;
    }
 
    inline void SetTo(bool bValue, const FProperty* Property, int32 ArrayIndex = 0)
    {
        Struct->SetPropertyValueFlag(Flag, bValue, Data, Property, ArrayIndex);
    }
 
    inline void Set(const FProperty* Property, int32 ArrayIndex = 0)
    {
        SetTo(/*bValue*/ true, Property, ArrayIndex);
    }
 
    inline void Clear(const FProperty* Property, int32 ArrayIndex = 0)
    {
        SetTo(/*bValue*/ false, Property, ArrayIndex);
    }
 
    inline void Reset()
    {
        Struct->ResetPropertyValueFlags(Flag, Data);
    }
 
    inline void Serialize(FStructuredArchiveRecord Record)
    {
        Struct->SerializePropertyValueFlags(Flag, Data, Record, GetArchiveFieldName());
    }
 
private:
    inline static FArchiveFieldName GetArchiveFieldName()
    {
        static_assert(Flag == EPropertyValueFlags::Initialized || Flag == EPropertyValueFlags::Serialized);
        if constexpr (Flag == EPropertyValueFlags::Initialized)
        {
            return TEXT("PropertyValueInitializedFlags");
        }
        else
        {
            return TEXT("PropertyValueSerializedFlags");
        }
    }
 
    const UStruct* Struct = nullptr;
    void* Data = nullptr;
};
 
// A property is initialized if it has a value set on it.
// A property may be uninitialized if it has no default and has never been set.
// A property may be uninitialized if it is an unknown property in an InstanceDataObject (IDO)
// and has no value on a particular instance or has had its value unset while being fixed up.
using FInitializedPropertyValueState = TPropertyValueState<EPropertyValueFlags::Initialized>;
 
// A property is serialized if a value was loaded into it during serialization.
// A property may be initialized without having been serialized because a template object provided a default.
// A property may be serialized without being initialized if its value was removed following serialization.
using FSerializedPropertyValueState = TPropertyValueState<EPropertyValueFlags::Serialized>;
 
class FUnknownPropertyTree
{
public:
    explicit FUnknownPropertyTree(const UObject* Owner);
 
    TSharedPtr<FPropertyPathNameTree> Find() const;
 
    TSharedPtr<FPropertyPathNameTree> FindOrCreate();
 
    void Destroy();
 
private:
    const UObject* Owner = nullptr;
};
 
class FUnknownEnumNames
{
public:
    explicit FUnknownEnumNames(const UObject* Owner);
 
    void Add(const UEnum* Enum, FPropertyTypeName EnumTypeName, FName EnumValueName);
 
    void Find(FPropertyTypeName EnumTypeName, TArray<FName>& OutNames, bool& bOutHasFlags) const;
 
    bool IsEmpty() const;
 
    void Destroy();
 
private:
    friend void AppendHash(FBlake3& Builder, const FUnknownEnumNames& EnumNames);
 
    const UObject* Owner = nullptr;
};
 
} // UE
 
#undef UE_API
 
#endif // WITH_EDITORONLY_DATA