NumericTypeInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Algo/Find.h"
#include "Templates/IsIntegral.h"
#include "Templates/ValueOrError.h"
#include "Misc/ExpressionParserTypes.h"
#include "Math/BasicMathExpressionEvaluator.h"
#include "Internationalization/FastDecimalFormat.h"
#include "Misc/Attribute.h"
 
enum class EUnit : uint8;
 
DECLARE_MULTICAST_DELEGATE(FOnSettingChanged);
 
template<typename NumericType>
struct INumericTypeInterface
{
    virtual ~INumericTypeInterface() {}
 
    virtual int32 GetMinFractionalDigits() const = 0;
    virtual int32 GetMaxFractionalDigits() const = 0;
    virtual bool GetIndicateNearlyInteger() const { return false; };
 
    virtual void SetMinFractionalDigits(const TAttribute<TOptional<int32>>& NewValue) = 0;
    virtual void SetMaxFractionalDigits(const TAttribute<TOptional<int32>>& NewValue) = 0;
 
    virtual void SetIndicateNearlyInteger(const TAttribute<TOptional<bool>>& NewValue) {};
 
    virtual FString ToString(const NumericType& Value) const = 0;
    virtual TOptional<NumericType> FromString(const FString& InString, const NumericType& ExistingValue) = 0;
 
    virtual bool IsCharacterValid(TCHAR InChar) const = 0;
 
    virtual FOnSettingChanged* GetOnSettingChanged() { return nullptr; }
};
 
template<typename NumericType>
struct TDefaultNumericTypeInterface : INumericTypeInterface<NumericType>
{
 
    static const int16 DefaultMinFractionalDigits = 1;
 
    static const int16 DefaultMaxFractionalDigits = 6;
 
    static const bool DefaultIndicateNearlyInteger = false;
 
    int16 MinFractionalDigits = DefaultMinFractionalDigits;
 
    int16 MaxFractionalDigits = DefaultMaxFractionalDigits;
 
    bool bIndicateNearlyInteger = false;
 
    virtual int32 GetMinFractionalDigits() const override
    {
        return IntCastChecked<int32>(MinFractionalDigits);
    }
    virtual int32 GetMaxFractionalDigits() const override
    {
        return IntCastChecked<int32>(MaxFractionalDigits);
    }
 
    virtual bool GetIndicateNearlyInteger() const override
    { 
        return bIndicateNearlyInteger;
    };
 
    virtual void SetMinFractionalDigits(const TAttribute<TOptional<int32>>& NewValue) override
    {
        MinFractionalDigits = NewValue.Get().IsSet() ? IntCastChecked<int16>(FMath::Max(0, NewValue.Get().GetValue())) :
            DefaultMinFractionalDigits;
    }
 
    virtual void SetMaxFractionalDigits(const TAttribute<TOptional<int32>>& NewValue) override
    {
        MaxFractionalDigits = NewValue.Get().IsSet() ? IntCastChecked<int16>(FMath::Max(0, NewValue.Get().GetValue())) :
            DefaultMaxFractionalDigits;
    }
 
    virtual void SetIndicateNearlyInteger(const TAttribute<TOptional<bool>>& NewValue) override
    {
        bIndicateNearlyInteger = NewValue.Get().IsSet() ? NewValue.Get().GetValue() :
            DefaultIndicateNearlyInteger;
    }
 
    virtual FString ToString(const NumericType& Value) const override
    {
        const FNumberFormattingOptions NumberFormattingOptions = FNumberFormattingOptions()
            .SetUseGrouping(false)
            .SetMinimumFractionalDigits(TIsIntegral<NumericType>::Value ? 0 : MinFractionalDigits)
            .SetMaximumFractionalDigits(TIsIntegral<NumericType>::Value ? 0 : FMath::Max(MaxFractionalDigits, MinFractionalDigits))
            .SetIndicateNearlyInteger(TIsIntegral<NumericType>::Value ? false : bIndicateNearlyInteger);
        return FastDecimalFormat::NumberToString(Value, ExpressionParser::GetLocalizedNumberFormattingRules(), NumberFormattingOptions);
    }
 
    virtual TOptional<NumericType> FromString(const FString& InString, const NumericType& InExistingValue) override
    {
        // Attempt to parse a number of type NumericType. Need to parse all the characters.
        FNumberParsingOptions ParsingOption = FNumberParsingOptions().SetUseGrouping(false).SetUseClamping(true);
 
        {
            NumericType PrimaryValue{};
            int32 PrimaryParsedLen = 0;
            bool PrimaryResult =  FastDecimalFormat::StringToNumber(*InString, InString.Len(), ExpressionParser::GetLocalizedNumberFormattingRules(), ParsingOption, PrimaryValue, &PrimaryParsedLen);
            if(PrimaryResult && PrimaryParsedLen == InString.Len())
            {
                return PrimaryValue;
            }
        }
 
        {
            NumericType FallbackValue{};
            int32 FallbackParsedLen = 0;
            bool FallbackResult = FastDecimalFormat::StringToNumber(*InString, InString.Len(), FastDecimalFormat::GetCultureAgnosticFormattingRules(), ParsingOption, FallbackValue, &FallbackParsedLen);
            if (FallbackResult && FallbackParsedLen == InString.Len())
            {
                return FallbackValue;
            }
        }
 
        // Attempt to parse it as an expression
        static FBasicMathExpressionEvaluator Parser;
 
        TValueOrError<double, FExpressionError> Result = Parser.Evaluate(*InString, static_cast<double>(InExistingValue));
        if (Result.IsValid())
        {
            return FMath::Clamp((NumericType)Result.GetValue(), TNumericLimits<NumericType>::Lowest(), TNumericLimits<NumericType>::Max());
        }
 
        return TOptional<NumericType>();
    }
 
    virtual bool IsCharacterValid(TCHAR InChar) const override
    {
        auto IsValidLocalizedCharacter = [InChar]() -> bool
        {
            const FDecimalNumberFormattingRules& NumberFormattingRules = ExpressionParser::GetLocalizedNumberFormattingRules();
            return InChar == NumberFormattingRules.GroupingSeparatorCharacter
                || InChar == NumberFormattingRules.DecimalSeparatorCharacter
                || Algo::Find(NumberFormattingRules.DigitCharacters, InChar) != 0;
        };
 
        static const FString ValidChars = TEXT("1234567890()-+=\\/.,*^%%");
        return InChar != 0 && (ValidChars.GetCharArray().Contains(InChar) || IsValidLocalizedCharacter());
    }
};
 
enum class EUnit : uint8;
template<typename> struct FNumericUnit;
 
template<typename NumericType>
struct TNumericUnitTypeInterface : TDefaultNumericTypeInterface<NumericType>
{
    const EUnit UnderlyingUnits;
 
    TOptional<EUnit> FixedDisplayUnits;
 
    TOptional<EUnit> UserDisplayUnits;
 
    TNumericUnitTypeInterface(EUnit InUnits);
 
    virtual FString ToString(const NumericType& Value) const override;
 
    virtual TOptional<NumericType> FromString(const FString& ValueString, const NumericType& InExistingValue) override;
 
    virtual bool IsCharacterValid(TCHAR InChar) const override;
 
    void SetupFixedDisplay(const NumericType& InValue);
};