enum.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_enum_h
#define INCL_evo_enum_h

#include "substring.h"

namespace evo {


template<class T>
struct EnumMapIterator : EnumIterator<typename T::Type, (int)T::FIRST, (int)T::LAST> {
    typedef EnumMapIterator<T> This;
    typedef EnumIterator<typename T::Type, (int)T::FIRST, (int)T::LAST> BaseType;
#if defined(EVO_OLDCC2)
    typedef typename BaseType::EnumType EnumType;
#else
    using typename BaseType::EnumType;
#endif

    // Documented by parents

    EnumMapIterator() {
    }

    EnumMapIterator(const This& src) : EnumIterator<typename T::Type, (int)T::FIRST, (int)T::LAST>(src) {
    }

    EnumMapIterator(EnumType value) : EnumIterator<typename T::Type, (int)T::FIRST, (int)T::LAST>(value) {
    }

    EnumMapIterator(IteratorPos pos) : EnumIterator<typename T::Type, (int)T::FIRST, (int)T::LAST>(pos) {
    }

    This& operator=(const This& src) {
        BaseType::operator=(src);
        return *this;
    }

    This& operator=(EnumType value) {
        BaseType::operator=(value);
        return *this;
    }

    This& operator=(IteratorPos pos) {
        BaseType::operator=(pos);
        return *this;
    }

    SubString value_str() const {
        SubString result;
        if (!BaseType::end_)
            result = T::get_string(BaseType::value_);
        return result;
    }
};


#define EVO_ENUM_MAP(ENUM, FIRST_VAL, LAST_VAL, UNKNOWN_VAL, ...) \
    struct ENUM ## Enum { \
        typedef ENUM Type; \
        typedef EnumMapIterator< ENUM ## Enum > Iter; \
        static const ENUM FIRST   = FIRST_VAL; \
        static const ENUM LAST    = LAST_VAL; \
        static const ENUM UNKNOWN = UNKNOWN_VAL; \
        static const evo::SubStringMapList& map() { \
            static const evo::SubString LIST[] = { __VA_ARGS__ }; \
            static const evo::SubStringMapList MAP(LIST, evo::fixed_array_size(LIST)); \
            return MAP; \
        } \
        static ENUM get_enum(const evo::SubString& key) \
            { return map().find_enum<ENUM>(key, FIRST, LAST, UNKNOWN); } \
        static ENUM get_enum(int val) \
            { return (val < (int)FIRST || val > (int)LAST ? UNKNOWN : (ENUM)val); } \
        static int get_int(ENUM val) \
            { return (int)val; } \
        static SubString get_string(ENUM val) \
            { return map().get_enum_string(val, FIRST, LAST); } \
    }

#define EVO_ENUM_REMAP(ENUM, FIRST_VAL, LAST_VAL, UNKNOWN_VAL, REMAP_ARRAY, ...) \
    struct ENUM ## Enum { \
        typedef ENUM Type; \
        typedef EnumMapIterator< ENUM ## Enum > Iter; \
        static const ENUM FIRST   = FIRST_VAL; \
        static const ENUM LAST    = LAST_VAL; \
        static const ENUM UNKNOWN = UNKNOWN_VAL; \
        static const ENUM* get_remap_array() { \
            return REMAP_ARRAY; \
        } \
        static const SizeT* get_reverse_remap_array() { \
            static const SubStringMapList::ReverseRemap< ENUM ## Enum > REVERSE(get_remap_array()); \
            return REVERSE.array; \
        } \
        static const evo::SubStringMapList& map() { \
            static const evo::SubString LIST[] = { __VA_ARGS__ }; \
            static const evo::SubStringMapList MAP(LIST, evo::fixed_array_size(LIST)); \
            return MAP; \
        } \
        static ENUM get_enum(const evo::SubString& key) \
            { return map().find_enum_remap<Type>(get_remap_array(), key, FIRST, LAST, UNKNOWN); } \
        static ENUM get_enum(int val) \
            { return (val < (int)FIRST || val > (int)LAST ? UNKNOWN : (ENUM)val); } \
        static int get_int(ENUM val) \
            { return (int)val; } \
        static SubString get_string(ENUM val) \
            { return map().get_enum_string_remap(get_reverse_remap_array(), val, FIRST, LAST); } \
    }

#define EVO_ENUM_MAP_PREFIXED(ENUM, PREFIX, ...) \
    EVO_ENUM_MAP(ENUM, (ENUM)((int)(PREFIX ## UNKNOWN) + 1), (ENUM)((int)(PREFIX ## ENUM_END) - 1), PREFIX ## UNKNOWN, __VA_ARGS__)

#define EVO_ENUM_REMAP_PREFIXED(ENUM, PREFIX, REMAP_ARRAY, ...) \
    EVO_ENUM_REMAP(ENUM, (ENUM)((int)(PREFIX ## UNKNOWN) + 1), (ENUM)((int)(PREFIX ## ENUM_END) - 1), PREFIX ## UNKNOWN, REMAP_ARRAY, __VA_ARGS__)

#if defined(EVO_CPP11)

    #define EVO_ENUM_CLASS_MAP(ENUM, ...) \
        struct ENUM ## Enum { \
            typedef ENUM Type; \
            typedef EnumMapIterator< ENUM ## Enum > Iter; \
            static const ENUM FIRST = (ENUM)((int)(ENUM::UNKNOWN) + 1); \
            static const ENUM LAST = (ENUM)((int)(ENUM::ENUM_END) - 1); \
            static const evo::SubStringMapList& map() { \
                static const evo::SubString LIST[] = { __VA_ARGS__ }; \
                static const evo::SubStringMapList MAP(LIST, evo::fixed_array_size(LIST)); \
                return MAP; \
            } \
            static ENUM get_enum(const evo::SubString& key) \
                { return map().find_enum_class<ENUM>(key); } \
            static ENUM get_enum(int val) \
                { return (val <= (int)ENUM::UNKNOWN || val >= (int)ENUM::ENUM_END ? ENUM::UNKNOWN : (ENUM)val); } \
            static int get_int(ENUM val) \
                { return (int)val; } \
            static SubString get_string(ENUM val) \
                { return map().get_enum_class_string(val); } \
        }

    #define EVO_ENUM_CLASS_REMAP(ENUM, REMAP_ARRAY, ...) \
        struct ENUM ## Enum { \
            typedef ENUM Type; \
            typedef EnumMapIterator< ENUM ## Enum > Iter; \
            static const ENUM FIRST = (ENUM)((int)(ENUM::UNKNOWN) + 1); \
            static const ENUM LAST = (ENUM)((int)(ENUM::ENUM_END) - 1); \
            static const ENUM* get_remap_array() { \
                return REMAP_ARRAY; \
            } \
            static const SizeT* get_reverse_remap_array() { \
                static const SubStringMapList::ReverseRemap< ENUM ## Enum > REVERSE(get_remap_array()); \
                return REVERSE.array; \
            } \
            static const evo::SubStringMapList& map() { \
                static const evo::SubString LIST[] = { __VA_ARGS__ }; \
                static const evo::SubStringMapList MAP(LIST, evo::fixed_array_size(LIST)); \
                return MAP; \
            } \
            static ENUM get_enum(const evo::SubString& key) \
                { return map().find_enum_remap<Type>(get_remap_array(), key, FIRST, LAST, Type::UNKNOWN); } \
            static ENUM get_enum(int val) \
                { return (val <= (int)ENUM::UNKNOWN || val >= (int)ENUM::ENUM_END ? ENUM::UNKNOWN : (ENUM)val); } \
            static int get_int(ENUM val) \
                { return (int)val; } \
            static SubString get_string(ENUM val) \
                { return map().get_enum_string_remap(get_reverse_remap_array(), val, FIRST, LAST); } \
        }
#endif


#define EVO_ENUM_TRAITS(ENUM, TRAITS, START_VAL, ...) \
    struct ENUM ## EnumTraits { \
        typedef ENUM Type; \
        static const ENUM START = START_VAL; \
        static const TRAITS& get(ENUM value) { \
            return data()[(int)value - (int)START]; \
        } \
    private: \
        static const TRAITS* data() { \
            static const TRAITS DATA[] = { __VA_ARGS__ }; \
            return DATA; \
        } \
    };

#if defined(EVO_CPP11)

    #define EVO_ENUM_CLASS_TRAITS(ENUM, TRAITS, ...) \
        struct ENUM ## EnumTraits { \
            typedef ENUM Type; \
            static const ENUM START = ENUM::UNKNOWN; \
            static const TRAITS& get(ENUM value) { \
                return data()[(int)value - (int)START]; \
            } \
        private: \
            static const TRAITS* data() { \
                static const TRAITS DATA[] = { __VA_ARGS__ }; \
                return DATA; \
            } \
        };
#endif


}
#endif