EnumUtils.h

Go to the documentation of this file.

// Copyright(c) PixoVR, LLC. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include <type_traits>
 
namespace EnumUtils
{
    namespace {
        template<typename TEnum>
        void ForEachEnumValue_IncrementImpl(TEnum BeginEnumValue, TEnum EndEnumValue, TFunction<void(TEnum)> Op)
        {
            if (ensure(Op))
            {
                for (TEnum EnumValue = BeginEnumValue; EnumValue <= EndEnumValue;)
                {
                    Op(EnumValue);
 
                    uint8 EnumIndex = (uint8)EnumValue;
                    EnumValue = (TEnum)(++EnumIndex);
                }
            }
        }
 
        template<typename TEnum>
        void ForEachEnumValue_ShiftImpl(TEnum BeginEnumValue, TEnum EndEnumValue, TFunction<void(TEnum)> Op)
        {
            if (ensure(Op))
            {
                if(BeginEnumValue == (TEnum)0)
                {
                    Op((TEnum)0);
                }
 
                const uint8 EndEnumIndex = (uint8)EndEnumValue;
 
                for (uint8 ShiftIndex = FMath::Log2((float)BeginEnumValue); ; ++ShiftIndex)
                {
                    const uint8 EnumIndex = (1 << ShiftIndex);
                    const TEnum EnumValue = (TEnum)EnumIndex;
                    if (EnumIndex > EndEnumIndex || EnumIndex == 0)
                    {
                        break;
                    }
                    Op(EnumValue);
                }
            }
        }
    };
 
    template<typename TEnum>
    struct GetEnumValueAsText_Implementation
    {
        FText operator()(TEnum EnumValue) const {
            UEnum* EnumClass = StaticEnum<TEnum>();
            LowLevelFatalError(TEXT("GetEnumValueAsText function is not implemented for %s"), *EnumClass->CppType);
 
            return FText::FromString("INVALID");
        }
    };
 
    //template<> struct EnumUtils::GetEnumValueAsText_Implementation<CustomEnumType>
    //{
    //  FText operator()(CustomEnumType EnumValue) const {
    //      // Your logic here
    //      return FText::FromString("Some text");
    //  }
    //};
    template<typename TEnum>
    FText GetEnumValueAsText(TEnum EnumValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<TEnum>::Value, "Should only call this with enum types");
        return GetEnumValueAsText_Implementation<TEnum>()(EnumValue);
    }
 
    //template<> struct EnumUtils::GetEnumValueAsText_Implementation<CustomEnumType>
    //{
    //  FText operator()(CustomEnumType EnumValue) const {
    //      // Your logic here
    //      return FText::FromString("Some text");
    //  }
    //};
    template<typename TEnum>
    FString GetEnumValueAsString(TEnum EnumValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<TEnum>::Value, "Should only call this with enum types");
        return GetEnumValueAsText<TEnum>(EnumValue).ToString();
    }
 
    template<typename TEnum>
    bool IsValidEnumValue(int64 Value)
    {
        // For the C++ enum.
        static_assert(TIsEnum<TEnum>::Value, "Should only call this with enum types");
 
        UEnum* EnumClass = StaticEnum<TEnum>();
        check(EnumClass != nullptr);
        return EnumClass->IsValidEnumValue(Value);
    }
 
    template<typename TEnum>
    void ForEachEnumValue(TEnum BeginEnumValue, TEnum EndEnumValue, TFunction<void(TEnum)> Op)
    {
        // For the C++ enum.
        static_assert(TIsEnum<TEnum>::Value, "Should only call this with enum types");
 
        // BeginEnumValue and EndEnumValue should be range limits in ascending order (e.g. Begin <= End )
        check((uint8)BeginEnumValue <= (uint8)EndEnumValue);
 
        UEnum* EnumClass = StaticEnum<TEnum>();
        check(EnumClass != nullptr);
 
        int64 CheckIndexType = (int64)EndEnumValue;
        --CheckIndexType;
        if (EnumClass->IsValidEnumValue(CheckIndexType))
        {
            ForEachEnumValue_IncrementImpl(BeginEnumValue, EndEnumValue, Op);
        }
        else
        {
            ForEachEnumValue_ShiftImpl(BeginEnumValue, EndEnumValue, Op);
        }
    }
 
    template<typename T>
    auto GetEnumValue(const T InValue)
    {
        return static_cast<typename std::underlying_type<T>::type>(InValue);
    }
    template<class TEnum>
    auto GetEnumsOffset(TEnum FirstValue, TEnum SecondValue)
    {
        static_assert(TIsEnum<TEnum>::Value, "Should only call this with enum types");
        return EnumUtils::GetEnumValue(FirstValue) - EnumUtils::GetEnumValue(SecondValue);
    }
};