enum.h

 
#ifndef _aspose_system_enum_h_
#define _aspose_system_enum_h_
#include <type_traits>
#include <system/string.h>
#include <system/array.h>
#include <system/exceptions.h>
#include <system/type_info.h>
#include <system/boxed_enum.h>
 
#include <unordered_map>
#include <string>
#include <cctype>
 
template<class T>
struct EnumMetaInfo; // declared out of System namespace
 
namespace System
{
    template<class E, class G>
    struct Enum;
 
    template <class E, class G, class Guard = void>
    struct EnumGetNameHelper
    {
        template<class T>
        static String GetName(T value)
        {
            const auto& values = EnumMetaInfo<E>::values();
            for (auto val : values)
            {
                if (static_cast<E>(value) == val.first)
                    return String(val.second);
            }
 
            return String();
        }
    };
 
    template <class E, class G>
    struct EnumGetNameHelper<E, G, typename EnumMetaInfo<E>::Flags>
    {
        template<class T>
        static String GetName(T value)
        {
            using UnderlyingType = typename std::underlying_type<E>::type;
            // If you got error here it means that enum E was translated without metainformation
            // Add [CodePorting.Translator.Cs2Cpp.CppEnumEnableMetadata] attribute to fix the problem.
            String result;
            const auto& values = EnumMetaInfo<E>::values();
            bool first = true;
            for (auto val : values)
            {
                if (static_cast<UnderlyingType>(val.first))
                {
                    if (static_cast<E>(value) == val.first)
                        return val.second;
 
                    if (Enum<E,G>::HasFlag(static_cast<E>(value), val.first))
                    {
                        if (!first)
                        {
                            result += u", ";
                        }
                        else
                        {
                            first = false;
                        }
                        result += val.second;
                    }
                } 
                else if (!static_cast<UnderlyingType>(value)) 
                {
                    return val.second;
                }
            }
            return result;
        }
    };
 
    template <class E, class G, class Guard = void>
    struct EnumParseHelper {
        static E Parse(const String& str, bool ignoreCase = false)
        {
            E result;
            if (!Enum<E, G>::TryParse(str, ignoreCase, result))
                throw ArgumentException(String::Format(u"Requested value '{0}' was not found.", str));
 
            return result;
        }
    };
 
    template <class E, class G>
    struct EnumParseHelper<E, G, typename EnumMetaInfo<E>::Flags>{
        static E Parse(const String& str, bool ignoreCase = false)
        {
            E result = (E)0;
            const auto& vals = str.Split(u',');
            for (int i = 0; i < vals->get_Count(); ++i)
            {
                E val;
                if (!Enum<E, G>::TryParse(vals[i].Trim(), ignoreCase, val))
                {
                    if (vals->get_Count() == 1)
                    {
                        std::string s = vals[0].ToAsciiString();
                        if (!s.empty() && std::all_of(s.begin(), s.end(), ::isdigit))
                            return (E)std::stoi(s);
                    }
                    throw ArgumentException(String::Format(u"Requested value '{0}' was not found.", str));
                }
                result = result | val;
            }
            return result;
        }
    };
 
    template<class E, class Guard = typename std::enable_if<std::is_enum<E>::value>::type>
    struct Enum
    {
        using UnderlyingType = typename std::underlying_type<E>::type;
 
        static const System::TypeInfo& GetUnderlyingType()
        {
            return System::BoxedValue<UnderlyingType>::Type();
        }
 
        static bool HasFlag(E value, E mask)
        {
            return (static_cast<UnderlyingType>(value) & static_cast<UnderlyingType>(mask)) == static_cast<UnderlyingType>(mask);
        }
 
        static bool IsDefined(E value)
        {
            const auto& values = EnumMetaInfo<E>::values();
            for( auto val : values )
            {
                if( value == val.first )
                    return true;
            }
            return false;
        }
 
        template<class T>
        static typename std::enable_if< std::is_convertible<T, UnderlyingType>::value, bool>::type IsDefined(T value)
        {
            return IsDefined(static_cast<E>(value));
        }
 
        static bool IsDefined(const String& name)
        {
            E result;
            return TryParse(name, result);
        }
 
        template<class T>
        static typename std::enable_if< std::is_same<T,E>::value || std::is_convertible<T, UnderlyingType>::value, String>::type GetName(T value)
        {
            // If you got error here it means that enum E was translated without metainformation
            // Add [CodePorting.Translator.Cs2Cpp.CppEnumEnableMetadata] attribute to fix the problem.
            return EnumGetNameHelper<E, Guard>::GetName(value);
        }
 
        template <class T>
        static typename std::enable_if<std::is_same<T, E>::value || std::is_convertible<T, UnderlyingType>::value,  String>::type GetDescription(T value)
        {
            // If you got error here it means that enum E was translated without metainformation
            // Enable option "generate_enum_descriptions"
            // and add [CodePorting.Translator.Cs2Cpp.CppEnumEnableMetadata] attribute to fix the problem.
            const auto& values = EnumMetaInfo<E>::descriptions();
            for (auto val : values)
            {
                if (static_cast<E>(value) == val.first)
                    return val.second == nullptr ? String() : String(val.second);
            }
            return String();
        }
 
        static E Parse(const String& str, bool ignoreCase = false)
        {
            return EnumParseHelper<E, Guard>::Parse(str, ignoreCase);
        }
 
        static bool TryParse(const String& str, E& result)
        {
            return TryParse(str, false, result);
        }
 
        static bool TryParse(const String& str, bool ignoreCase, E& result)
        {
            const auto& values = ::EnumMetaInfo<E>::values();
            for( auto val : values )
            {
                if (str.Equals(val.second, ignoreCase ? StringComparison::OrdinalIgnoreCase : StringComparison::Ordinal))
                {
                    result = val.first;
                    return true;
                }
            }
 
            return false;
        }
       
        static ArrayPtr<E> GetValues()
        {
            auto res = MakeObject<Array<E>>();
            const auto& values = ::EnumMetaInfo<E>::values();
            for( auto val : values )
            {
                res->data().push_back( val.first );
            }
 
            return res;
        }
 
        static ArrayPtr<String> GetNames()
        {
            auto res = MakeObject<Array<String>>();
            const auto& values = ::EnumMetaInfo<E>::values();
            for( auto val : values )
            {
                res->data().push_back( val.second );
            }
 
            return res;
        }
 
        template <typename T, typename _ = typename std::enable_if<std::is_arithmetic<T>::value || std::is_enum<T>::value>::type>
        static int Compare(E a, T b)
        {
            return static_cast<UnderlyingType>(a) < static_cast<UnderlyingType>(b) ? -1 :
                (static_cast<UnderlyingType>(a) > static_cast<UnderlyingType>(b) ? 1 : 0);
        }
    };
 
    class ASPOSECPP_SHARED_CLASS EnumValuesBase
    {
    protected:
        ASPOSECPP_SHARED_API EnumValuesBase(const TypeInfo &type);
        virtual ASPOSECPP_SHARED_API ~EnumValuesBase();
        virtual ASPOSECPP_SHARED_API ArrayPtr<int64_t> GetValues() const = 0;
        virtual ASPOSECPP_SHARED_API ArrayPtr<String> GetNames() const = 0;
        virtual ASPOSECPP_SHARED_API SharedPtr<Object> GetValueOf(const String& str, bool ignoreCase) const = 0;
        virtual ASPOSECPP_SHARED_API SharedPtr<Object> GetValueOf(long val) const = 0;
        virtual ASPOSECPP_SHARED_API const System::TypeInfo& GetUnderlyingType() const = 0;
 
    public:
        static ASPOSECPP_SHARED_API ArrayPtr<int64_t> GetValues(const TypeInfo& type);
        static ASPOSECPP_SHARED_API ArrayPtr<String> GetNames(const TypeInfo& type);
        static ASPOSECPP_SHARED_API SharedPtr<Object> Parse(const TypeInfo& type, const String& str, bool ignoreCase);
        static ASPOSECPP_SHARED_API SharedPtr<Object> ToObject(const TypeInfo& type, uint64_t value);
        static ASPOSECPP_SHARED_API SharedPtr<Object> ToObject(const TypeInfo& type, const SharedPtr<Object>& value);
        static ASPOSECPP_SHARED_API const System::TypeInfo& GetUnderlyingType(const TypeInfo& type);
 
    private:
        struct value_enumerators {
            std::unordered_map<std::u16string, const EnumValuesBase*> m_enumerators;
        };
        static value_enumerators& GetEnumerators();
        static const EnumValuesBase& GetEnumerator(const TypeInfo& type);
    };
 
    template <typename E, class Guard = typename std::enable_if<std::is_enum<E>::value>::type>
    class EnumValues : public EnumValuesBase
    {
    public:
        EnumValues() : EnumValuesBase(TypeInfo::BoxedValueType<E>()) {}
        virtual ~EnumValues() {}
        virtual ArrayPtr<int64_t> GetValues() const override
        {
            auto res = MakeObject<Array<int64_t>>();
            ArrayPtr<E> values = Enum<E>::GetValues();
            for (auto v : values->data())
                res->data().push_back((int64_t)v);
            return res;
        }
 
        virtual ArrayPtr<String> GetNames() const override
        {
            return Enum<E>::GetNames();
        }
 
        virtual SharedPtr<Object> GetValueOf(const String& str, bool ignoreCase) const override
        {
            auto values = ::EnumMetaInfo<E>::values();
            if (ignoreCase)
            {
                auto lower = str.ToLower();
                for (auto v : values)
                    if (System::String(v.second).ToLower() == lower)
                        return MakeObject<BoxedEnum<E>>(v.first);
            }
            else
            {
                auto wcs = str.ToU16Str();
                for (auto v : values)
                    if (v.second == wcs)
                        return MakeObject<BoxedEnum<E>>(v.first);
            }
            char *str_end = nullptr;
            const auto ascii_str = str.ToAsciiString();
            long val = std::strtol(ascii_str.c_str(), &str_end, 10);
            if (ascii_str.c_str() != str_end)
                return MakeObject<BoxedEnum<E>>((E)val);
 
            throw System::ComponentModel::InvalidEnumArgumentException();
        }
 
        virtual SharedPtr<Object> GetValueOf(long val) const override
        {
            return MakeObject<BoxedEnum<E>>((E)val);
        }
 
        virtual const System::TypeInfo& GetUnderlyingType() const override
        {
            return Enum<E>::GetUnderlyingType();
        }
    };
 
    template<class T>
    static bool IsEnumMetaInfoDefined(T value) {
        return Enum<T>::IsDefined(value);
    }
 
    template <class T>
    static System::String EnumGetName(T value) {
        return Enum<T>::GetName(value);
    }
} // namespace System
 
#endif // _aspose_system_enum_h_