ProgressCancel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp ProgressCancel
 
#pragma once
 
#include "Containers/Array.h"
#include "HAL/CriticalSection.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "MathUtil.h"
#include "Misc/DateTime.h"
#include "Misc/ScopeLock.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
 
#include <atomic>
 
class FProgressCancel;
 
 
namespace UE
{
namespace Geometry
{
 
 
struct FGeometryError
{
    int32 ErrorCode = 0;
    FText Message;
    FDateTime Timestamp;
    TArray<unsigned char> CustomData;
 
    FGeometryError() 
    { 
        Timestamp = FDateTime::Now();
    }
 
    FGeometryError(int32 Code, const FText& MessageIn) : ErrorCode(Code), Message(MessageIn) 
    {
        Timestamp = FDateTime::Now();
    }
};
 
struct FGeometryWarning
{
    int32 WarningCode = 0;
    FText Message;
    FDateTime Timestamp;
    TArray<unsigned char> CustomData;
 
 
    FGeometryWarning()
    {
        Timestamp = FDateTime::Now();
    }
 
    FGeometryWarning(int32 Code, const FText& MessageIn) : WarningCode(Code), Message(MessageIn)
    {
        Timestamp = FDateTime::Now();
    }
};
 
 
enum class EGeometryResultType
{
    Success = 0,
    InProgress = 1,
    Cancelled = 2,
    PartialResult = 3,
    Failure = 4
};
 
 
struct FGeometryResult
{
    EGeometryResultType Result;
    TArray<FGeometryError> Errors;
    TArray<FGeometryWarning> Warnings;
 
 
    FGeometryResult()
    {
        Result = EGeometryResultType::Success;
    }
 
    FGeometryResult(EGeometryResultType ResultType) 
    {
        Result = ResultType;
    }
 
    void UpdateResultType(EGeometryResultType NewType)
    {
        Result = NewType;
    }
 
    void SetFailed() { Result = EGeometryResultType::Failure; }
    void SetCancelled() { Result = EGeometryResultType::Cancelled; }
 
    void SetSuccess() { Result = EGeometryResultType::Success; }
 
    inline void SetSuccess(bool bSuccess, FProgressCancel* Progress = nullptr );
 
    inline void SetFailed(FText ErrorMessage, int ResultCode = 0);
 
    inline bool CheckAndSetCancelled( FProgressCancel* Progress );
 
    void AddError(FGeometryError Error) 
    { 
        Errors.Add(Error); 
    }
    
    void AddWarning(FGeometryWarning Warning)
    { 
        Warnings.Add(Warning); 
    }
 
    bool HasFailed() const { return Result == EGeometryResultType::Failure; }
 
    bool HasResult() const { return Result == EGeometryResultType::Success || Result == EGeometryResultType::PartialResult; }
 
    static FGeometryResult Failed() { return FGeometryResult(EGeometryResultType::Failure); }
    static FGeometryResult Cancelled() { return FGeometryResult(EGeometryResultType::Cancelled); }
};
 
 
 
} // end namespace UE::Geometry
} // end namespace UE
 
 
 
 
 
class FProgressCancel
{
private:
    bool WasCancelled = false;  // will be set to true if CancelF() ever returns true
 
    // Progress tracking data
    struct FProgressData
    {
        // Active range of progress tracking -- progress should not go out of this range
        float CurrentMin = 0;
        float CurrentMax = 1;
        // Number of nested scopes currently affecting the active range
        int ScopeDepth = 0;
        // Message describing the current work being done
        FText Message;
 
        float Range() const
        {
            return CurrentMax - CurrentMin;
        }
 
        // Advance progress without going beyond the current range
        float SafeAdvance(float CurrentFraction, float AdvanceAmount) const
        {
            return FMathf::Min(CurrentMax, CurrentFraction + Range() * AdvanceAmount);
        }
    };
    FProgressData Progress;
    FText ProgressMessage;
    int MaxMessageDepth = -1; // If set to a positive value, message will not be updated by scopes below this depth
 
    // Current total progress, in range [0, 1]
    std::atomic<float> ProgressFraction = 0;
 
    // critical section for accesses to the Progress Message
    mutable FCriticalSection MessageCS;
 
    GEOMETRYCORE_API void StartWorkScope(FProgressData& SaveProgressFrameOut, float StepSize, const FText& Message);
 
    GEOMETRYCORE_API void EndWorkScope(const FProgressData& SavedProgressFrame);
 
public:
    TFunction<bool()> CancelF = []() { return false; };
 
    void SetMaxMessageDepth(int32 ScopeDepth)
    {
        MaxMessageDepth = ScopeDepth;
    }
 
    void ClearMaxMessageDepth()
    {
        MaxMessageDepth = -1;
    }
 
    bool Cancelled()
    {
        if (WasCancelled)
        {
            return true;
        }
        WasCancelled = CancelF();
        return WasCancelled;
    }
 
    friend class FProgressScope;
 
    // Simple helper to track progress in a local scope on an optional FProgressCancel
    // Will still work if the ProgressCancel is null (just does nothing in that case)
    class FProgressScope
    {
        FProgressCancel* ProgressCancel;
        FProgressData SavedProgressData;
        bool bEnded = false;
 
    public:
 
        GEOMETRYCORE_API FProgressScope(FProgressCancel* ProgressCancel, float ProgressAmount, const FText& Message = FText());
 
        FProgressScope() : ProgressCancel(nullptr)
        {}
 
        FProgressScope(const FProgressScope& Other) = delete;
        FProgressScope& operator=(const FProgressScope& Other) = delete;
        FProgressScope(FProgressScope&& Other) noexcept : ProgressCancel(Other.ProgressCancel), SavedProgressData(MoveTemp(Other.SavedProgressData)), bEnded(Other.bEnded)
        {
            Other.ProgressCancel = nullptr;
            Other.bEnded = true;
        }
        FProgressScope& operator=(FProgressScope&& Other) noexcept
        {
            if (this != &Other)
            {
                ProgressCancel = Other.ProgressCancel;
                SavedProgressData = MoveTemp(Other.SavedProgressData);
                bEnded = Other.bEnded;
                Other.ProgressCancel = nullptr;
                Other.bEnded = true;
            }
            return *this;
        }
 
        ~FProgressScope()
        {
            if (!bEnded)
            {
                Done();
            }
        }
 
        GEOMETRYCORE_API void Done();
 
        inline void AdvanceProgressBy(float Amount)
        {
            if (ProgressCancel)
            {
                ProgressCancel->AdvanceCurrentScopeProgressBy(Amount);
            }
        }
 
        inline void AdvanceProgressToward(float TargetProgressFrac, float FractionToward)
        {
            if (ProgressCancel)
            {
                ProgressCancel->AdvanceCurrentScopeProgressToward(TargetProgressFrac, FractionToward);
            }
        }
 
        inline float GetDistanceTo(float TargetProgressFrac)
        {
            if (ProgressCancel)
            {
                return ProgressCancel->GetCurrentScopeDistanceTo(TargetProgressFrac);
            }
 
            return 0;
        }
 
        inline float GetProgress()
        {
            if (ProgressCancel)
            {
                return ProgressCancel->GetCurrentScopeProgress();
            }
 
            return 1;
        }
 
        inline void SetProgressTo(float NewProgressFrac)
        {
            if (ProgressCancel)
            {
                ProgressCancel->SetCurrentScopeProgressTo(NewProgressFrac);
            }
        }
    };
 
    static GEOMETRYCORE_API FProgressScope CreateScopeTo(FProgressCancel* ProgressCancel, float ProgressTo, const FText& Message = FText());
 
    float GetProgress() const
    {
        return FMathf::Clamp(ProgressFraction, 0, 1);
    }
 
    FText GetProgressMessage() const
    {
        FScopeLock MessageLock(&MessageCS);
        return ProgressMessage;
    }
 
    void SetProgressMessage(const FText& Message)
    {
        if (MaxMessageDepth == -1 || Progress.ScopeDepth < MaxMessageDepth)
        {
            Progress.Message = Message;
            FScopeLock MessageLock(&MessageCS);
            ProgressMessage = Message;
        }
    }
 
    void AdvanceCurrentScopeProgressBy(float Amount)
    {
        ProgressFraction = Progress.SafeAdvance(ProgressFraction, Amount);
    }
 
    void AdvanceCurrentScopeProgressToward(float TargetProgressFrac, float FractionToward)
    {
        float TargetProgressFraction = FMathf::Max(ProgressFraction, Progress.CurrentMin + Progress.Range() * TargetProgressFrac);
        ProgressFraction = Progress.SafeAdvance(ProgressFraction, FMathf::Lerp(ProgressFraction, TargetProgressFraction, FractionToward));
    }
 
    float GetCurrentScopeProgress()
    {
        float Range = Progress.Range();
        return Range > 0 ? (ProgressFraction - Progress.CurrentMin) / Range : 1;
    }
 
    float GetCurrentScopeDistanceTo(float TargetProgressFrac)
    {
        return TargetProgressFrac - GetCurrentScopeProgress();
    }
 
    void SetCurrentScopeProgressTo(float NewProgressFrac)
    {
        ProgressFraction = FMathf::Clamp(Progress.CurrentMin + Progress.Range() * NewProgressFrac, ProgressFraction, Progress.CurrentMax);
    }
 
public:
 
    enum class EMessageLevel
    {
        // Note: Corresponds to EToolMessageLevel in InteractiveToolsFramework/ToolContextInterfaces.h
 
        Internal = 0,
        UserMessage = 1,
        UserNotification = 2,
        UserWarning = 3,
        UserError = 4
    };
 
    struct FMessageInfo
    {
        FText MessageText;
        EMessageLevel MessageLevel;
        FDateTime Timestamp;
    };
 
    void AddWarning(const FText& MessageText, EMessageLevel MessageLevel)
    {
        Warnings.Add(FMessageInfo{ MessageText , MessageLevel, FDateTime::Now() });
    }
 
    TArray<FMessageInfo> Warnings;
};
 
 
 
 
void UE::Geometry::FGeometryResult::SetSuccess(bool bSuccess, FProgressCancel* Progress)
{
    if (Progress && Progress->Cancelled())
    {
        Result = EGeometryResultType::Cancelled;
    }
    else
    {
        Result = (bSuccess) ? EGeometryResultType::Success : EGeometryResultType::Failure;
    }
}
 
 
void UE::Geometry::FGeometryResult::SetFailed(FText ErrorMessage, int ResultCode)
{
    Result = EGeometryResultType::Failure;
    Errors.Add(FGeometryError(ResultCode, ErrorMessage));
}
 
 
bool UE::Geometry::FGeometryResult::CheckAndSetCancelled(FProgressCancel* Progress)
{
    if (Progress && Progress->Cancelled())
    {
        Result = EGeometryResultType::Cancelled;
        return true;
    }
    return false;
}