如何在C ++中将运行时类型鉴别器映射到模板实例（无需手动枚举它们）？

Question

Given an enum of type discriminators representing various small types:

enum TypesEnum {
    IntT, 
    DoubleT, 
    ShortStringT
};

Suppose I have a template SomeType<typename A, typename B, typename C> . This is a type that I read and write to sets of memory-mapped files, whose layout/stride is determined by the types; the runtime types are stored as a triplet of the enum discriminators above.

I need to write various tools which can load these files and perform operations on them, like SomeType<A,B,C> => SomeType<B,A,C> and so forth. In these tools, I therefore have a rather awkward layer which translates the type discriminators on-disk into generic lambdas wrapping operations implemented with template instances for the correct types.

This looks like:

static std::map< std::tuple<Discrim, Discrim, Discrim>, some_op_fn_t > = 
    {
        {std::make_tuple(IntT, DoubleT, ShortStringT), SomeOperation<int,double,char[16]>() },
         std::make_tuple(IntT, IntT, ShortStringT), SomeOperation<int,int,char[16]>() },
        ...
    };
... look up the correct function pointer and call it with the path to the files ...

where typedef std::function<bool(void)> some_op_fn_t , whose implementations in template<A,B,C> class SomeOperation do a bunch of work with side-effects to disk.

Now, this quickly gets pretty tedious as the list of types and number of different operations grow. The trick is I cannot use virtual inheritance to simply have a type-erased SomeType which operates on abstract/virtual value types; it's much too slow to do the indirection and pointer chasing. I need to have dead reckoning and contiguous, packed value data, suitable (in the case of floats and doubles) for passing directly to BLAS.

Are there any techniques for automating the creation of interfaces/layers such as this? Something like a type-level combinations would help, where I could connect the enum to the types just once, and then expand all the instances of the mapping. Is that possible?

Worst case I can write a script to generate the code, but ugh...

Answer 1

First, an easy part, a mapping between type and enum value:

template <typename T> struct EnumValue;

template <> struct EnumValue<int> : std::integral_constant<TypesEnum, IntT> {};
template <> struct EnumValue<double> : std::integral_constant<TypesEnum, DoubleT> {};
template <> struct EnumValue<char[16]> : std::integral_constant<TypesEnum, ShortStringT> {};

Then an easy helper function:

using TupleT = std::tuple<int, double, char[16]>;

template <typename ... Ts> // Might be T1, T2, T3, but lazy to type
constexpr auto make_my_pair()
{
    return std::make_pair(std::make_tuple(EnumValue<Ts>::value...), &SomeOperation<Ts...>);
}

Now the Cartesian product using index_sequence

template <std::size_t I>
constexpr std::pair<TypesEnumTuple, some_op_fn_t>
make_my_pair()
{
    constexpr std::size_t N = std::tuple_size<TupleT>();
    return make_my_pair<
        std::tuple_element_t<(I / (N * N)) % N, TupleT>,
        std::tuple_element_t<(I / N) % N, TupleT>,
        std::tuple_element_t<(I / 1) % N, TupleT>
    >();
}

template <std::size_t ... Is>
std::map<TypesEnumTuple, some_op_fn_t>
make_my_map(std::index_sequence<Is...>)
{
    return {make_my_pair<Is>()...};
}

And finally:

// 27 = std::tuple_size<TupleT>() * std::tuple_size<TupleT>() * std::tuple_size<TupleT>()
// as we have T1, T2, T3
static const std::map<TypesEnumTuple, some_op_fn_t> m =
    make_my_map(std::make_index_sequence<27>());

Demo