enum.hpp

Go to the documentation of this file.

 
#include <string.h>
#include <limits>
 
// 126, so that FLECS_ENUM_MAX_COUNT is 127 which is the largest value 
// representable by an int8_t.
#define FLECS_ENUM_MAX(T) _::to_constant<T, 126>::value
#define FLECS_ENUM_MAX_COUNT (FLECS_ENUM_MAX(int) + 1)
 
// Flag to turn off enum reflection
#ifdef FLECS_CPP_NO_ENUM_REFLECTION
#define FLECS_CPP_ENUM_REFLECTION_SUPPORT 0
#endif
 
// Test if we're using a compiler that supports the required features
#ifndef FLECS_CPP_ENUM_REFLECTION_SUPPORT
#if !defined(__clang__) && defined(__GNUC__)
#if __GNUC__ > 7 || (__GNUC__ == 7 && __GNUC_MINOR__ >= 5)
#define FLECS_CPP_ENUM_REFLECTION_SUPPORT 1
#else
#define FLECS_CPP_ENUM_REFLECTION_SUPPORT 0
#endif
#else
#define FLECS_CPP_ENUM_REFLECTION_SUPPORT 1
#endif
#endif
 
#if defined(__clang__) && __clang_major__ >= 16
// https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307
#define flecs_enum_cast(T, v) __builtin_bit_cast(T, v)
#elif defined(__GNUC__) && __GNUC__ > 10
#define flecs_enum_cast(T, v) __builtin_bit_cast(T, v)
#else
#define flecs_enum_cast(T, v) static_cast<T>(v)
#endif
 
namespace flecs {
 
namespace _ {
template <typename E, underlying_type_t<E> Value>
struct to_constant {
    static constexpr E value = flecs_enum_cast(E, Value);
};
 
template <typename E, underlying_type_t<E> Value>
constexpr E to_constant<E, Value>::value;
}
 
template <typename E>
struct enum_data;
 
template <typename E>
static enum_data<E> enum_type(flecs::world_t *world);
 
template <typename E>
struct enum_last {
    static constexpr E value = FLECS_ENUM_MAX(E);
};
 
/* Utility macro to override enum_last trait */
#define FLECS_ENUM_LAST(T, Last)\
    namespace flecs {\
    template<>\
    struct enum_last<T> {\
        static constexpr T value = Last;\
    };\
    }
 
namespace _ {
 
#if INTPTR_MAX == INT64_MAX
    #ifdef ECS_TARGET_MSVC
        #if _MSC_VER >= 1929
            #define ECS_SIZE_T_STR "unsigned __int64"
        #else
            #define ECS_SIZE_T_STR "unsigned int"
        #endif 
    #elif defined(__clang__)
        #define ECS_SIZE_T_STR "size_t"
    #else
        #ifdef ECS_TARGET_WINDOWS
            #define ECS_SIZE_T_STR "constexpr size_t; size_t = long long unsigned int"
        #else
            #define ECS_SIZE_T_STR "constexpr size_t; size_t = long unsigned int"
        #endif
    #endif
#else
    #ifdef ECS_TARGET_MSVC
        #if _MSC_VER >= 1929
            #define ECS_SIZE_T_STR "unsigned __int32"
        #else
            #define ECS_SIZE_T_STR "unsigned int"
        #endif 
    #elif defined(__clang__)
        #define ECS_SIZE_T_STR "size_t"
    #else
        #ifdef ECS_TARGET_WINDOWS
            #define ECS_SIZE_T_STR "constexpr size_t; size_t = unsigned int"
        #else
            #define ECS_SIZE_T_STR "constexpr size_t; size_t = unsigned int"
        #endif
    #endif
#endif
 
template <typename E>
constexpr size_t enum_type_len() {
    return ECS_FUNC_TYPE_LEN(, enum_type_len, ECS_FUNC_NAME) 
        - (sizeof(ECS_SIZE_T_STR) - 1u);
}
 
#if defined(ECS_TARGET_CLANG)
#if ECS_CLANG_VERSION < 13
template <typename E, E C>
constexpr bool enum_constant_is_valid() {
    return !((
        (ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(bool, enum_constant_is_valid) +
            enum_type_len<E>() + 6 /* ', C = ' */] >= '0') &&
        (ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(bool, enum_constant_is_valid) +
            enum_type_len<E>() + 6 /* ', C = ' */] <= '9')) ||
        (ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(bool, enum_constant_is_valid) +
            enum_type_len<E>() + 6 /* ', C = ' */] == '-'));
}
#else
template <typename E, E C>
constexpr bool enum_constant_is_valid() {
    return (ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(bool, enum_constant_is_valid) +
        enum_type_len<E>() + 6 /* ', E C = ' */] != '(');
}
#endif
#elif defined(ECS_TARGET_GNU)
template <typename E, E C>
constexpr bool enum_constant_is_valid() {
    return (ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(constexpr bool, enum_constant_is_valid) +
        enum_type_len<E>() + 8 /* ', E C = ' */] != '(');
}
#else
/* Use different trick on MSVC, since it uses hexadecimal representation for
 * invalid enum constants. We can leverage that msvc inserts a C-style cast
 * into the name, and the location of its first character ('(') is known. */
template <typename E, E C>
constexpr bool enum_constant_is_valid() {
    return ECS_FUNC_NAME[ECS_FUNC_NAME_FRONT(bool, enum_constant_is_valid) +
        enum_type_len<E>() + 1] != '(';
}
#endif
 
/* Without this wrapper __builtin_bit_cast doesn't work */
template <typename E, underlying_type_t<E> C>
constexpr bool enum_constant_is_valid_wrap() {
    return enum_constant_is_valid<E, flecs_enum_cast(E, C)>();
}
 
template <typename E, E C>
struct enum_is_valid {
    static constexpr bool value = enum_constant_is_valid<E, C>();
};
 
template <typename E, E C>
static const char* enum_constant_to_name() {
    static const size_t len = ECS_FUNC_TYPE_LEN(
        const char*, enum_constant_to_name, ECS_FUNC_NAME);
    static char result[len + 1] = {};
    return ecs_cpp_get_constant_name(
        result, ECS_FUNC_NAME, string::length(ECS_FUNC_NAME),
            ECS_FUNC_NAME_BACK);
}
 
template <typename E, typename Handler>
struct enum_reflection {
    using U = underlying_type_t<E>;
 
    template <U Low, U High, typename... Args>
    static constexpr U each_enum_range(U last_value, Args&... args) {
        return High - Low <= 1
            ? High == Low
                ? Handler::template handle_constant<Low>(last_value, args...)
                : Handler::template handle_constant<High>(
                    Handler::template handle_constant<Low>(last_value, args...), 
                    args...)
            : each_enum_range<(Low + High) / 2 + 1, High>(
                    each_enum_range<Low, (Low + High) / 2>(last_value, args...),
                    args...
              );
    }
 
    template <U Low, U High, typename... Args>
    static constexpr U each_mask_range(U last_value, Args&... args) {
        // If Low shares any bits with Current Flag, or if High is less 
        // than/equal to Low (and High isn't negative because max-flag signed)
        return (Low & High) || (High <= Low && High != high_bit)
            ? last_value
            : Handler::template handle_constant<High>(
                each_mask_range<Low, ((High >> 1) & ~high_bit)>(last_value, args...),
                args...
              );
    }
 
    template <U Value = static_cast<U>(FLECS_ENUM_MAX(E)), typename... Args>
    static constexpr U each_enum(Args&... args) {
        return each_mask_range<Value, high_bit>(
            each_enum_range<0, Value>(0, args...), args...);
    }
    /* to avoid warnings with bit manipulation, calculate the high bit with an
       unsigned type of the same size: */
    using UU = typename std::make_unsigned<U>::type;
    static const U high_bit = 
        static_cast<U>(static_cast<UU>(1) << (sizeof(UU) * 8 - 1));
};
 
template<typename T>
struct enum_constant {
    int32_t index; // Global index used to obtain world local entity id
    T value;
    T offset;
    const char *name;
};
 
template <typename E>
struct enum_type {
private:
    using This = enum_type<E>;
    using U = underlying_type_t<E>;
 
    struct reflection_count {
        template <U Value, 
            flecs::if_not_t< enum_constant_is_valid_wrap<E, Value>() > = 0>
        static constexpr U handle_constant(U last_value) {
            return last_value;
        }
 
        template <U Value, 
            flecs::if_t< enum_constant_is_valid_wrap<E, Value>() > = 0>
        static constexpr U handle_constant(U last_value) {
            return 1 + last_value;
        }
    };
 
    struct reflection_init {
        template <U Value, 
            flecs::if_not_t< enum_constant_is_valid_wrap<E, Value>() > = 0>
        static U handle_constant(U last_value, This&) {
            // Search for constant failed. Pass last valid value through.
            return last_value;
        }
 
        template <U Value, 
            flecs::if_t< enum_constant_is_valid_wrap<E, Value>() > = 0>
        static U handle_constant(U last_value, This& me) {
            // Constant is valid, so fill reflection data.
            auto v = Value;
            const char *name = enum_constant_to_name<E, flecs_enum_cast(E, Value)>();
 
            ++me.max; // Increment cursor as we build constants array.
 
            // If the enum was previously contiguous, and continues to be 
            // through the current value...
            if (me.has_contiguous && static_cast<U>(me.max) == v && me.contiguous_until == v) {
                ++me.contiguous_until;
            }
 
            // else, if the enum was never contiguous and hasn't been set as not
            // contiguous...
            else if (!me.contiguous_until && me.has_contiguous) {
                me.has_contiguous = false;
            }
 
            ecs_assert(!(last_value > 0 && 
                v < std::numeric_limits<U>::min() + last_value), 
                ECS_UNSUPPORTED,
                "Signed integer enums causes integer overflow when recording "
                "offset from high positive to low negative. Consider using "
                "unsigned integers as underlying type.");
 
            me.constants[me.max].value = v;
            me.constants[me.max].offset = v - last_value;
            me.constants[me.max].name = name;
            if (!me.constants[me.max].index) {
                me.constants[me.max].index = 
                    flecs_component_ids_index_get();
            }
 
            return v;
        }
    };
public:
 
    enum_type() {
        // Initialize/reset reflection data values to default state.
        min = 0;
        max = -1;
        has_contiguous = true;
        contiguous_until = 0;
 
        enum_reflection<E, reflection_init>::
            template each_enum< static_cast<U>(enum_last<E>::value) >(*this);
    }
 
    static enum_type<E>& get() {
        static _::enum_type<E> instance;
        return instance;
    }
 
    flecs::entity_t entity(E value) const {
        int index = index_by_value(value);
        if (index >= 0) {
            return constants[index].id;
        }
        return 0;
    }
 
    void register_for_world(flecs::world_t *world, flecs::entity_t id) {
#if !FLECS_CPP_ENUM_REFLECTION_SUPPORT
        ecs_abort(ECS_UNSUPPORTED, "enum reflection requires gcc 7.5 or higher")
#endif
 
        ecs_log_push();
        ecs_cpp_enum_init(world, id, type<U>::id(world));
 
        for (U v = 0; v < static_cast<U>(max + 1); v ++) {
            if (constants[v].index) {
                flecs::entity_t constant = ecs_cpp_enum_constant_register(world,
                    type<E>::id(world), 0, constants[v].name, &constants[v].value, 
                    type<U>::id(world), sizeof(U));
 
                flecs_component_ids_set(world, constants[v].index, constant);
            }
        }
        
        ecs_log_pop();
    }
 
    int min;
    int max;
    bool has_contiguous;
 
    // If enum constants start not-sparse, contiguous_until will be the index of
    // the first sparse value, or end of the constants array
    U contiguous_until;
 
    // Compile-time generated count of enum constants.
    static constexpr unsigned int constants_size = 
        enum_reflection<E, reflection_count>::
            template each_enum< static_cast<U>(enum_last<E>::value) >();
 
    // Constants array is sized to the number of found-constants, or 1 
    // to avoid 0-sized array
    enum_constant<U> constants[constants_size? constants_size: 1] = {};
};
 
template <typename E, if_t< is_enum<E>::value > = 0>
inline static void init_enum(flecs::world_t *world, flecs::entity_t id) {
    _::enum_type<E>::get().register_for_world(world, id);
}
 
template <typename E, if_not_t< is_enum<E>::value > = 0>
inline static void init_enum(flecs::world_t*, flecs::entity_t) { }
 
} // namespace _
 
template <typename E>
struct enum_data {
    using U = underlying_type_t<E>;
 
    enum_data(flecs::world_t *world, _::enum_type<E>& impl)
        : world_(world)
        , impl_(impl) { }
    
    bool is_valid(U value) {
        int index = index_by_value(value);
        if (index < 0) {
            return false;
        }
        return impl_.constants[index].index != 0;
    }
 
    bool is_valid(E value) {
        return is_valid(static_cast<U>(value));
    }
 
    int index_by_value(U value) const {
        if (impl_.max < 0) {
            return -1;
        }
        // Check if value is in contiguous lookup section
        if (impl_.has_contiguous && value < impl_.contiguous_until && value >= 0) {
            return static_cast<int>(value);
        }
        U accumulator = impl_.contiguous_until? impl_.contiguous_until - 1: 0;
        for (int i = static_cast<int>(impl_.contiguous_until); i <= impl_.max; ++i) {
            accumulator += impl_.constants[i].offset;
            if (accumulator == value) {
                return i;
            }
        }
        return -1;
    }
 
    int index_by_value(E value) const {
        return index_by_value(static_cast<U>(value));
    }
 
    int first() const {
        return impl_.min;
    }
 
    int last() const {
        return impl_.max;
    }
 
    int next(int cur) const {
        return cur + 1;
    }
 
    flecs::entity entity() const;
    flecs::entity entity(U value) const;
    flecs::entity entity(E value) const;
 
    flecs::world_t *world_;
    _::enum_type<E>& impl_;
};
 
template <typename E>
enum_data<E> enum_type(flecs::world_t *world) {
    _::type<E>::id(world); // Ensure enum is registered
    auto& ref = _::enum_type<E>::get();
    return enum_data<E>(world, ref);
}
 
} // namespace flecs