RangeBound.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Templates/TypeHash.h"
#include "Containers/EnumAsByte.h"
#include "Misc/FrameNumber.h"
#include "Misc/DateTime.h"
 
namespace ERangeBoundTypes
{
    enum Type
    {
        Exclusive,
 
        Inclusive,
 
        Open
    };
}
 
 
template<typename ElementType>
class TRangeBound
{
public:
 
    /*~ Typedef used to pass/return small element types by value rather than const& */
    typedef typename TCallTraits<ElementType>::ParamType ElementValueOrConstRef;
 
    [[nodiscard]] TRangeBound()
        : Type(ERangeBoundTypes::Open)
        , Value()
    { }
 
    [[nodiscard]] TRangeBound(ElementValueOrConstRef InValue)
        : Type(ERangeBoundTypes::Inclusive)
        , Value(InValue)
    { }
 
public:
 
    [[nodiscard]] bool operator==(const TRangeBound& Other) const
    {
        return ((Type == Other.Type) && (IsOpen() || (Value == Other.Value)));
    }
 
    [[nodiscard]] bool operator!=(const TRangeBound& Other) const
    {
        return ((Type != Other.Type) || (!IsOpen() && (Value != Other.Value)));
    }
 
public:
 
    [[nodiscard]] inline ElementValueOrConstRef GetValue() const
    {
        check(Type != ERangeBoundTypes::Open);
 
        return Value;
    }
 
 
    inline void SetValue(ElementValueOrConstRef NewValue)
    {
        check(Type != ERangeBoundTypes::Open);
 
        Value = NewValue;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsClosed() const
    {
        return (Type != ERangeBoundTypes::Open);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsExclusive() const
    {
        return (Type == ERangeBoundTypes::Exclusive);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsInclusive() const
    {
        return (Type == ERangeBoundTypes::Inclusive);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsOpen() const
    {
        return (Type == ERangeBoundTypes::Open);
    }
 
public:
 
    friend class FArchive& operator<<(class FArchive& Ar, TRangeBound& Bound)
    {
        return Ar << (uint8&)Bound.Type << Bound.Value;
    }
 
    friend uint32 GetTypeHash(const TRangeBound& Bound)
    {
        return (GetTypeHash((uint8)Bound.Type) + 23 * GetTypeHash(Bound.Value));
    }
 
public:
 
    [[nodiscard]] static inline TRangeBound Exclusive(ElementValueOrConstRef Value)
    {
        TRangeBound Result;
 
        Result.Type = ERangeBoundTypes::Exclusive;
        Result.Value = Value;
 
        return Result;
    }
 
    [[nodiscard]] static inline TRangeBound Inclusive(ElementValueOrConstRef Value)
    {
        TRangeBound Result;
 
        Result.Type = ERangeBoundTypes::Inclusive;
        Result.Value = Value;
 
        return Result;
    }
 
    [[nodiscard]] static inline TRangeBound Open()
    {
        TRangeBound Result;
 
        Result.Type = ERangeBoundTypes::Open;
 
        return Result;
    }
 
public:
 
    [[nodiscard]] static inline TRangeBound FlipInclusion(const TRangeBound& Bound)
    {
        if (Bound.IsExclusive())
        {
            return Inclusive(Bound.Value);
        }
 
        if (Bound.IsInclusive())
        {
            return Exclusive(Bound.Value);
        }
 
        return Bound;
    }
 
    [[nodiscard]] static inline const TRangeBound& MaxLower(const TRangeBound& A, const TRangeBound& B)
    {
        if (A.IsOpen()) { return B; }
        if (B.IsOpen()) { return A; }
        if (A.Value > B.Value) { return A; }
        if (B.Value > A.Value) { return B; }
        if (A.IsExclusive()) { return A; }
 
        return B;
    }
 
    [[nodiscard]] static inline const TRangeBound& MaxUpper(const TRangeBound& A, const TRangeBound& B)
    {
        if (A.IsOpen()) { return A; }
        if (B.IsOpen()) { return B; }
        if (A.Value > B.Value) { return A; }
        if (B.Value > A.Value) { return B; }
        if (A.IsInclusive()) { return A; }
 
        return B;
    }
 
    [[nodiscard]] static inline const TRangeBound& MinLower(const TRangeBound& A, const TRangeBound& B)
    {
        if (A.IsOpen()) { return A; }
        if (B.IsOpen()) { return B; }
        if (A.Value < B.Value) { return A; }
        if (B.Value < A.Value) { return B; }
        if (A.IsInclusive()) { return A; }
 
        return B;
    }
 
    [[nodiscard]] static inline const TRangeBound& MinUpper(const TRangeBound& A, const TRangeBound& B)
    {
        if (A.IsOpen()) { return B; }
        if (B.IsOpen()) { return A; }
        if (A.Value < B.Value) { return A; }
        if (B.Value < A.Value) { return B; }
        if (A.IsExclusive()) { return A; }
 
        return B;
    }
 
private:
 
    TEnumAsByte<ERangeBoundTypes::Type> Type;
 
    ElementType Value;
};
 
 
/* Default range bounds for built-in types (for FProperty support)
 *****************************************************************************/
 
#define DEFINE_RANGEBOUND_WRAPPER_STRUCT(Name, ElementType) \
    struct Name : TRangeBound<ElementType> \
    { \
    private: \
        typedef TRangeBound<ElementType> Super; \
     \
    public: \
        Name() \
            : Super() \
        { } \
         \
        Name(const Super& Other) \
            : Super(Other) \
        { } \
         \
        Name(const ElementType InValue) \
            : Super(InValue) \
        { } \
         \
        static UE_FORCEINLINE_HINT Name Exclusive(ElementValueOrConstRef Value) \
        { \
            return static_cast<const Name&>(Super::Exclusive(Value)); \
        } \
         \
        static UE_FORCEINLINE_HINT Name Inclusive(ElementValueOrConstRef Value) \
        { \
            return static_cast<const Name&>(Super::Inclusive(Value)); \
        } \
         \
        static UE_FORCEINLINE_HINT Name Open() \
        { \
            return static_cast<const Name&>(Super::Open()); \
        } \
         \
        static UE_FORCEINLINE_HINT Name FlipInclusion(const Name& Bound) \
        { \
            return static_cast<const Name&>(Super::FlipInclusion(Bound)); \
        } \
         \
        static UE_FORCEINLINE_HINT const Name& MaxLower(const Name& A, const Name& B) \
        { \
            return static_cast<const Name&>(Super::MaxLower(A, B)); \
        } \
         \
        static UE_FORCEINLINE_HINT const Name& MaxUpper(const Name& A, const Name& B) \
        { \
            return static_cast<const Name&>(Super::MaxUpper(A, B)); \
        } \
         \
        static UE_FORCEINLINE_HINT const Name& MinLower(const Name& A, const Name& B) \
        { \
            return static_cast<const Name&>(Super::MinLower(A, B)); \
        } \
         \
        static UE_FORCEINLINE_HINT const Name& MinUpper(const Name& A, const Name& B) \
        { \
            return static_cast<const Name&>(Super::MinUpper(A, B)); \
        } \
    }; \
     \
    template <> \
    struct TIsBitwiseConstructible<Name, TRangeBound<ElementType>> \
    { \
        enum { Value = true }; \
    }; \
     \
    template <> \
    struct TIsBitwiseConstructible<TRangeBound<ElementType>, Name> \
    { \
        enum { Value = true }; \
    };
 
 
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FDateRangeBound,   FDateTime)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FDoubleRangeBound, double)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FFloatRangeBound,  float)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FInt8RangeBound,   int8)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FInt16RangeBound,  int16)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FInt32RangeBound,  int32)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FInt64RangeBound,  int64)
DEFINE_RANGEBOUND_WRAPPER_STRUCT(FFrameNumberRangeBound, FFrameNumber)