How can I get the index of a type in a variadic class template?

Question

I have a variadic Engine template class:

template <typename ... Components> class Engine;

I'd like to assign a number to each component at compile time which is equivalent to their ordering. This would be returned when making the following call:

template <typename Component> int ordinal();

So for example if:

Engine<PositionComponent, PhysicsComponent, InputComponent> engine;

was declared, the call:

engine.ordinal<PhysicsComponent>();

would return 1 and a similar call with InputComponent instead of PhysicsComponent would return 2.

Is it possible, and if yes, how would one go about it?

I found [this solution](http://stackoverflow.com/questions/18063451/get-index-of-a-tuple-elements-type) for tuples, I'm pretty sure you can adapt it for your use case. — Borgleader, Jun 09 '15 at 15:22

Barry · Accepted Answer · 2022-04-05T14:58:46.983

11

In Boost.Mp11, this is a short one-liner (as always):

template <typename... Components>
struct Engine {
    template <typename Component>
    static constexpr int ordinal() {
        return mp_find<Engine, Component>::value;
    }
};

Note that if Component is absent, this will return sizeof...(Components). If desired, you can add a static assertion to verify this.

My original answer follows below the fold...

So you want to find the index of Component in Components...?

template <typename... >
struct index;

// found it
template <typename T, typename... R>
struct index<T, T, R...>
: std::integral_constant<size_t, 0>
{ };

// still looking
template <typename T, typename F, typename... R>
struct index<T, F, R...>
: std::integral_constant<size_t, 1 + index<T,R...>::value>
{ };

Usage:

template <typename Component> 
size_t ordinal() { return index<Component, Components...>::value; }

As constructed, trying to get the ordinal of a Component not in Components... will be a compile error. Which seems appropriate.

edited Apr 05 '22 at 14:58

answered Jun 09 '15 at 15:25

Barry

286,269
29
621
977

1

Very clever solution by adding the result of `index::value` to 1! – Alejandro Jun 09 '15 at 15:31
Thanks. This is great. Do you know if the compiler will optimise the template iteration away? – Natalie Cuthbert Jun 09 '15 at 15:40
@NickCuthbert It will have to compile it all, but `index::value` is a compile-time constant - there is no runtime work involved there. – Barry Jun 09 '15 at 15:41
Good answer, but still you should add a case where the index is not actually found, which should perhaps return -1 or generate a static assertion. – Vladius Apr 05 '22 at 09:48
Also a case with an empty variadic pack is not handles appropriately. – Vladius Apr 12 '22 at 12:05

Yakk - Adam Nevraumont · Answer 2 · 2015-06-09T16:53:04.837

My goal below is to keep things in the compile-time realm as much as possible.

This is an alias to remove some boilerplate. std::integral_constant is a wonderful std type that stores a compile-time determined integer-type:

template<std::size_t I>
using size=std::integral_constant<std::size_t, I>;

Next, a index_of type, and an index_of_t that is slightly easier to use:

template<class...>struct types{using type=types;};
template<class T, class Types>struct index_of{};
template<class T, class...Ts>
struct index_of<T, types<T, Ts...>>:size<0>{};
template<class T, class T0, class...Ts>
struct index_of<T, types<T0, Ts...>>:size<
  index_of<T,types<Ts...>>::value +1
>{};

This alias returns a pure std::integral_constant, instead of a type inheriting from it:

template<class T, class...Ts>
using index_of_t = size< index_of<T, types<Ts...>>::value >;

Finally our function:

template <class Component>
static constexpr index_of_t<Component, Components...>
ordinal() const {return{};}

it is not only constexpr, it returns a value that encodes its value in its type. size<?> has a constexpr operator size_t() as well as an operator(), so you can use it in most spots that expect integer types seamlessly.

You could also use:

template<class Component>
using ordinal = index_of_t<Component, Components...>;

and now ordinal<Component> is a type representing the index of the component, instead of a function.

score 1 · Answer 3 · answered Jun 10 '15 at 23:06

1

I'm adding this for completeness sake, it utilizes C++11's constexpr functionality, and a few stl functions. I feel it is a little cleaner than the other solutions.

//Same type
template <typename Target,typename T,typename ...Rest>
constexpr typename std::enable_if<std::is_same<Target,T>::value, size_t>
_ordinal(){
    return 0;
}

//Different types
template <typename Target,typename T,typename ...Rest>
constexpr typename std::enable_if<!std::is_same<Target,T>::value, size_t>
_ordinal(){
    return 1+_ordinal<Target,Rest...>();
}

answered Jun 10 '15 at 23:06

RabtFt

153
15

You are missing `::type` part from the `std::enable_if` (even though you do have the `typename` there). – Adam Badura May 22 '17 at 12:07
Also the compilation error when the type looked for is not on the list is rather unfriendly I think (at least with GCC 6.3.0). And it doesn't say much about the real issue. Although I'm not sure how other solutions shown here look like in this scenario. – Adam Badura May 22 '17 at 12:08

score 0 · Answer 4 · edited Jun 09 '15 at 15:53

UNTESTED:

template <int, typename>
constexpr int index_of() { return -1; } // type not found

template <int N, typename Component, typename Cur, typename... Components>
constexpr int index_of() {
    return std::is_same<Component, Cur>::value ? N : index_of<N+1, Component, Components...>();
}

template <typename... Components>
template <typename Component>
constexpr int engine<Components...>::ordinal() {
    return index_of<0, Component, Components...>();
}

I could have used structs, but I find this much cleaner (without all the ::type ugliness).

If you want a compile-time error when the type is not found, change ordinal to:

template <typename... Components>
template <typename Component>
constexpr int engine<Components...>::ordinal() {
    static_assert(index_of<0, Component, Components...>()!=-1, "invalid component");
     return index_of<0, Component, Components...>();
}

How can I get the index of a type in a variadic class template?

4 Answers4

Linked