TransactionObjectEvent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/Guid.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SharedPointer.h"
 
class ITransactionObjectAnnotation;
 
struct FTransactionObjectDeltaChange
{
    FTransactionObjectDeltaChange()
        : bHasNameChange(false)
        , bHasOuterChange(false)
        , bHasExternalPackageChange(false)
        , bHasPendingKillChange(false)
        , bHasNonPropertyChanges(false)
    {
    }
 
    bool HasChanged() const
    {
        return bHasNameChange || bHasOuterChange || bHasExternalPackageChange || bHasPendingKillChange || bHasNonPropertyChanges || ChangedProperties.Num() > 0;
    }
 
    void Merge(const FTransactionObjectDeltaChange& InOther)
    {
        bHasNameChange |= InOther.bHasNameChange;
        bHasOuterChange |= InOther.bHasOuterChange;
        bHasExternalPackageChange |= InOther.bHasExternalPackageChange;
        bHasPendingKillChange |= InOther.bHasPendingKillChange;
        bHasNonPropertyChanges |= InOther.bHasNonPropertyChanges;
 
        for (const FName& OtherChangedPropName : InOther.ChangedProperties)
        {
            ChangedProperties.AddUnique(OtherChangedPropName);
        }
    }
 
    bool bHasNameChange : 1;
    bool bHasOuterChange : 1;
    bool bHasExternalPackageChange : 1;
    bool bHasPendingKillChange : 1;
    bool bHasNonPropertyChanges : 1;
    TArray<FName> ChangedProperties;
};
 
struct FTransactionObjectId
{
public:
    FTransactionObjectId() = default;
 
    explicit FTransactionObjectId(const UObject* Object)
    {
        SetObject(Object);
    }
 
    FTransactionObjectId(const FName InObjectPackageName, const FName InObjectName, const FName InObjectPathName, const FName InObjectOuterPathName, const FName InObjectExternalPackageName, const FName InObjectClassPathName)
        : ObjectPackageName(InObjectPackageName)
        , ObjectName(InObjectName)
        , ObjectPathName(InObjectPathName)
        , ObjectOuterPathName(InObjectOuterPathName)
        , ObjectExternalPackageName(InObjectExternalPackageName)
        , ObjectClassPathName(InObjectClassPathName)
    {
    }
 
    COREUOBJECT_API void SetObject(const UObject* Object);
 
    void Reset()
    {
        ObjectPackageName = FName();
        ObjectName = FName();
        ObjectPathName = FName();
        ObjectOuterPathName = FName();
        ObjectExternalPackageName = FName();
        ObjectClassPathName = FName();
    }
 
    void Swap(FTransactionObjectId& Other)
    {
        Exchange(ObjectPackageName, Other.ObjectPackageName);
        Exchange(ObjectName, Other.ObjectName);
        Exchange(ObjectPathName, Other.ObjectPathName);
        Exchange(ObjectOuterPathName, Other.ObjectOuterPathName);
        Exchange(ObjectExternalPackageName, Other.ObjectExternalPackageName);
        Exchange(ObjectClassPathName, Other.ObjectClassPathName);
    }
 
    friend bool operator==(const FTransactionObjectId& LHS, const FTransactionObjectId& RHS)
    {
        // The other fields are subsets of this data
        return LHS.ObjectPathName == RHS.ObjectPathName
            && LHS.ObjectExternalPackageName == RHS.ObjectExternalPackageName
            && LHS.ObjectClassPathName == RHS.ObjectClassPathName;
    }
 
    friend bool operator!=(const FTransactionObjectId& LHS, const FTransactionObjectId& RHS)
    {
        return !(LHS == RHS);
    }
 
    friend uint32 GetTypeHash(const FTransactionObjectId& Id)
    {
        return GetTypeHash(Id.ObjectPathName);
    }
 
    FName ObjectPackageName;
 
    FName ObjectName;
 
    FName ObjectPathName;
 
    FName ObjectOuterPathName;
 
    FName ObjectExternalPackageName;
 
    FName ObjectClassPathName;
};
 
struct FTransactionObjectChange
{
    FTransactionObjectId OriginalId;
 
    EObjectFlags OriginalObjectFlags = RF_NoFlags;
 
    FTransactionObjectDeltaChange DeltaChange;
};
 
enum class ETransactionObjectChangeCreatedBy : uint8
{
    TransactionRecord,
    TransactionAnnotation,
};
 
enum class ETransactionObjectEventType : uint8
{
    UndoRedo,
    Finalized,
    Snapshot,
};
 
class FTransactionObjectEvent
{
public:
    FTransactionObjectEvent() = default;
 
    FTransactionObjectEvent(const FGuid& InTransactionId, const FGuid& InOperationId, const ETransactionObjectEventType InEventType, const ETransactionObjectChangeCreatedBy InObjectChangeCreatedBy, const FTransactionObjectChange& InObjectChange, const TSharedPtr<ITransactionObjectAnnotation>& InAnnotation)
        : TransactionId(InTransactionId)
        , OperationId(InOperationId)
        , EventType(InEventType)
        , ObjectChangeCreatedBy(InObjectChangeCreatedBy)
        , ObjectChange(InObjectChange)
        , Annotation(InAnnotation)
    {
        check(TransactionId.IsValid());
        check(OperationId.IsValid());
    }
 
    const FGuid& GetTransactionId() const
    {
        return TransactionId;
    }
 
    const FGuid& GetOperationId() const
    {
        return OperationId;
    }
 
    ETransactionObjectEventType GetEventType() const
    {
        return EventType;
    }
 
    ETransactionObjectChangeCreatedBy GetObjectChangeCreatedBy() const
    {
        return ObjectChangeCreatedBy;
    }
 
    bool HasPendingKillChange() const
    {
        return ObjectChange.DeltaChange.bHasPendingKillChange;
    }
 
    bool HasNameChange() const
    {
        return ObjectChange.DeltaChange.bHasNameChange;
    }
 
    const FTransactionObjectId& GetOriginalObjectId() const
    {
        return ObjectChange.OriginalId;
    }
 
    EObjectFlags GetOriginalObjectFlags() const
    {
        return ObjectChange.OriginalObjectFlags;
    }
 
    FName GetOriginalObjectPackageName() const
    {
        return ObjectChange.OriginalId.ObjectPackageName;
    }
 
    FName GetOriginalObjectName() const
    {
        return ObjectChange.OriginalId.ObjectName;
    }
 
    FName GetOriginalObjectPathName() const
    {
        return ObjectChange.OriginalId.ObjectPathName;
    }
 
    FName GetOriginalObjectClassPathName() const
    {
        return ObjectChange.OriginalId.ObjectClassPathName;
    }
 
    bool HasOuterChange() const
    {
        return ObjectChange.DeltaChange.bHasOuterChange;
    }
 
    bool HasExternalPackageChange() const
    {
        return ObjectChange.DeltaChange.bHasExternalPackageChange;
    }
 
    FName GetOriginalObjectOuterPathName() const
    {
        return ObjectChange.OriginalId.ObjectOuterPathName;
    }
 
    FName GetOriginalObjectExternalPackageName() const
    {
        return ObjectChange.OriginalId.ObjectExternalPackageName;
    }
 
    bool HasIdOrPendingKillChanges() const
    {
        return ObjectChange.DeltaChange.bHasNameChange || ObjectChange.DeltaChange.bHasOuterChange || ObjectChange.DeltaChange.bHasExternalPackageChange || ObjectChange.DeltaChange.bHasPendingKillChange;
    }
 
    bool HasNonPropertyChanges(const bool InSerializationOnly = false) const
    {
        return (!InSerializationOnly && HasIdOrPendingKillChanges()) || ObjectChange.DeltaChange.bHasNonPropertyChanges;
    }
 
    bool HasPropertyChanges() const
    {
        return ObjectChange.DeltaChange.ChangedProperties.Num() > 0;
    }
 
    const TArray<FName>& GetChangedProperties() const
    {
        return ObjectChange.DeltaChange.ChangedProperties;
    }
 
    TSharedPtr<ITransactionObjectAnnotation> GetAnnotation() const
    {
        return Annotation;
    }
 
    void Merge(const FTransactionObjectEvent& InOther)
    {
        if (EventType == ETransactionObjectEventType::Snapshot)
        {
            EventType = InOther.EventType;
        }
 
        ObjectChange.DeltaChange.Merge(InOther.ObjectChange.DeltaChange);
    }
 
private:
    FGuid TransactionId;
    FGuid OperationId;
    ETransactionObjectEventType EventType = ETransactionObjectEventType::Finalized;
    ETransactionObjectChangeCreatedBy ObjectChangeCreatedBy = ETransactionObjectChangeCreatedBy::TransactionRecord;
    FTransactionObjectChange ObjectChange;
    TSharedPtr<ITransactionObjectAnnotation> Annotation;
};
 
struct FTransactionDiff
{
    FGuid TransactionId;
    FString TransactionTitle;
    TMap<FName, TSharedPtr<FTransactionObjectEvent>> DiffMap;
};