Change.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "HAL/Platform.h"
#include "HAL/PlatformCrt.h"
#include "Misc/AssertionMacros.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
 
class FFeedbackContext;
class FReferenceCollector;
class UObject;
 
class FChange
{
 
public:
    enum class EChangeStyle
    {
        InPlaceSwap,            // Call Execute() which returns new "opposite" FChange   (default)
        CommandPattern          // call Revert() to Undo and Apply() to Redo
    };
 
    virtual EChangeStyle GetChangeType() = 0;
 
    virtual TUniquePtr<FChange> Execute( UObject* Object ) = 0;
 
    virtual void Apply( UObject* Object ) = 0;
 
    virtual void Revert( UObject* Object ) = 0;
 
    virtual bool HasExpired( UObject* Object ) const { return false; }
 
    virtual void AddReferencedObjects( FReferenceCollector& Collector ) { }
 
    virtual FString ToString() const = 0;
 
    CORE_API virtual void PrintToLog( FFeedbackContext& FeedbackContext, const int32 IndentLevel = 0 );
 
    virtual SIZE_T GetSize() const { return 0; }
 
    virtual ~FChange()
    {
    }
 
protected:
 
    FChange()
    {
    }
 
private:
    // Non-copyable
    FChange( const FChange& ) = delete;
    FChange& operator=( const FChange& ) = delete;
 
};
 
 
 
class FSwapChange : public FChange
{
 
public:
    virtual EChangeStyle GetChangeType() final
    {
        return FChange::EChangeStyle::InPlaceSwap;
    }
 
    virtual void Apply(UObject* Object) final
    {
        check(false);
    }
 
    virtual void Revert(UObject* Object) final
    {
        check(false);
    }
 
};
 
 
class FCommandChange : public FChange
{
 
public:
    virtual EChangeStyle GetChangeType() final
    {
        return FChange::EChangeStyle::CommandPattern;
    }
 
    virtual TUniquePtr<FChange> Execute(UObject* Object) final
    {
        check(false);
        return nullptr;
    }
 
};
 
 
 
 
 
 
struct FCompoundChangeInput
{
    FCompoundChangeInput()
    {
    }
 
    explicit FCompoundChangeInput( FCompoundChangeInput&& RHS )
        : Subchanges( MoveTemp( RHS.Subchanges ) )
    {
    }
 
    TArray<TUniquePtr<FChange>> Subchanges;
 
private:
    // Non-copyable
    FCompoundChangeInput( const FCompoundChangeInput& ) = delete;
    FCompoundChangeInput& operator=( const FCompoundChangeInput& ) = delete;
};
 
 
 
class FCompoundChange : public FSwapChange
{
 
public:
 
    explicit FCompoundChange( FCompoundChangeInput&& InitInput )
        : Input( MoveTemp( InitInput ) )
    {
    }
 
    // Parent class overrides
    CORE_API virtual TUniquePtr<FChange> Execute( UObject* Object ) override;
    CORE_API virtual FString ToString() const override;
    CORE_API virtual void PrintToLog( class FFeedbackContext& FeedbackContext, const int32 IndentLevel = 0 ) override;
 
 
private:
    
    FCompoundChangeInput Input;
 
private:
    // Non-copyable
    FCompoundChange( const FCompoundChange& ) = delete;
    FCompoundChange& operator=( const FCompoundChange& ) = delete;
 
};