enum.hpp

#ifndef SIPLASPLAS_REFLECTION_STATIC_ENUM_HPP
#define SIPLASPLAS_REFLECTION_STATIC_ENUM_HPP

#include <siplasplas/utility/meta.hpp>
#include <string>
#include <limits>
#include <array>

namespace cpp
{
namespace static_reflection
{
namespace meta
{

template<
    typename SourceInfo,
    typename EnumType,
    typename Constants,
    typename ConstantsNames
>
class Enum;

#ifndef SIPLASPLAS_DOXYGEN_RUNNING // Doxygen shit
template<
    typename SourceInfo_,
    typename EnumType,
    EnumType... Constants,
    typename... ConstantsNames
>
class Enum<
    SourceInfo_,
    EnumType,
    ::cpp::meta::list<std::integral_constant<EnumType, Constants>...>,
    ::cpp::meta::list<ConstantsNames...>
>
#else

class Enum
#endif // SIPLASPLAS_DOXYGEN_RUNNING
{
public:
    using type = EnumType;
    using Type = EnumType;
    using UnderlyingType = typename std::underlying_type<EnumType>::type;
    using SourceInfo = SourceInfo_;
    using names_array_t  = std::array<const char*, sizeof...(ConstantsNames)>;
    using values_array_t = const EnumType[sizeof...(Constants)];

    constexpr Enum() = default;

    static constexpr std::size_t count()
    {
        static_assert(sizeof...(Constants) == sizeof...(ConstantsNames), "");
        return sizeof...(Constants);
    }

    static constexpr const names_array_t& names()
    {
        return _namesArray;
    }

    static constexpr const values_array_t& values()
    {
        return ::cpp::meta::PackToArray<EnumType, Constants...>::get();
    }

    static constexpr EnumType value(std::size_t i)
    {
        return values()[i];
    }

    static constexpr const char* name(std::size_t i)
    {
        return names()[i];
    }

    static constexpr const char* toString(const EnumType value)
    {
        return _toString(value, 0);
    }

    static constexpr EnumType fromString(const char* name)
    {
        return _fromString(name, 0);
    }

    static constexpr bool has(const char* name)
    {
        return _has(name, 0);
    }

    static constexpr bool has(const UnderlyingType value)
    {
        return _has(value, 0);
    }

private:
    static constexpr std::array<const char*, sizeof...(ConstantsNames)> _namesArray = {{::cpp::meta::StringToArray<ConstantsNames>::c_str()...}};
    static constexpr bool streq(const char* lhs, const char* rhs)
    {
        return ((*rhs and *lhs) ? (*lhs == *rhs) and streq(lhs + 1, rhs + 1) : (not *lhs and not *rhs));
    }

    static constexpr const char* _toString(const EnumType value, std::size_t i)
    {
        return (i < sizeof...(Constants)) ?
            ((value == Enum::value(i)) ? Enum::name(i) : _toString(value, i + 1))
        :
            nullptr;
    }

    static constexpr EnumType _fromString(const char* name, std::size_t i)
    {
        return (i < sizeof...(ConstantsNames)) ?
            (streq(name, Enum::name(i)) ? Enum::value(i) : _fromString(name, i + 1))
        :
            static_cast<EnumType>(std::numeric_limits<typename std::underlying_type<EnumType>::type>::max());
    }

    static constexpr bool _has(const char* name, std::size_t i)
    {
        return (i < sizeof...(ConstantsNames)) && (streq(name, Enum::name(i)) || _has(name, i + 1));
    }

    static constexpr bool _has(const UnderlyingType value, std::size_t i)
    {
        return (i < sizeof...(Constants)) && ((value == static_cast<UnderlyingType>(Enum::value(i))) || _has(value, i + 1));
    }
};

template<typename SourceInfo, typename EnumType, EnumType... Constants, typename... ConstantsNames>
constexpr typename Enum<
    SourceInfo,
    EnumType,
    ::cpp::meta::list<std::integral_constant<EnumType, Constants>...>,
    ::cpp::meta::list<ConstantsNames...>
>::names_array_t Enum<
    SourceInfo,
    EnumType,
    ::cpp::meta::list<std::integral_constant<EnumType, Constants>...>,
    ::cpp::meta::list<ConstantsNames...>
>::_namesArray;

} // namespace meta

namespace codegen
{

template<typename EnumType>
class Enum : public static_reflection::meta::Enum<
    static_reflection::meta::EmptySourceInfo<Enum<EnumType>>,
    EnumType,
    ::cpp::meta::list<
        std::integral_constant<EnumType, static_cast<EnumType>(0)>
    >,
    ::cpp::meta::list<
        ::cpp::meta::string<>
    >
>
{};

}

template<typename EnumType>
class Enum : public codegen::Enum<EnumType>
{};

} // namespace static_reflection
} // namespace cpp
#endif // SIPLASPLAS_REFLECTION_STATIC_ENUM_HPP