If I have two variadic template arguments, A
and B
, how can I ensure at compile-time that the types of all of the members of A
are also the types of a subset of B
(in the same order)?
Contrived example:
template<typename...A>
struct Foo {
template<typename...B>
static void bar()
{
}
}
...
Foo<Apple, Orange>:: template bar<Apple, Orange, Grape>(); // this compiles
Foo<Apple, Orange>:: template bar<Orange, Grape>(); // this doesn't
For a general subset I don't know, but if you can guarantee that B
is of the form A..., More...
, then this may do:
#include <functional>
#include <tuple>
template <typename ...A>
struct var_equal : std::false_type { };
template <typename A1, typename ...Aother, typename B1, typename ...Bother>
struct var_equal<std::tuple<A1, Aother...>, std::tuple<B1, Bother...>>
{
static const bool value = std::is_same<A1, B1>::value && var_equal<std::tuple<Aother...>, std::tuple<Bother...>>::value;
};
template <typename ...B>
struct var_equal<std::tuple<>, std::tuple<B...>> : std::true_type { };
template<typename...A>
struct Foo {
template<typename...B>
static void bar()
{
static_assert(var_equal<std::tuple<A...>, std::tuple<B...>>::value, "Hello");
}
};
(Sorry, var_equal
is a terrible name. It should be called something more appropriate, like initial_equal
.)
Update: Here is the general solution, worked out in detail by Luc Danton (see here for his beautifully styled code):
#include <type_traits>
#include <tuple>
template <typename Sub, typename Super>
struct subset_of : std::false_type {};
template<typename Same, typename... AOther, typename... BOther>
struct subset_of<std::tuple<Same, AOther...>, std::tuple<Same, BOther...>>
: subset_of<
std::tuple<AOther...>
, std::tuple<BOther...>
> {};
template<typename ADifferent, typename BDifferent, typename... AOther, typename... BOther>
struct subset_of<std::tuple<ADifferent, AOther...>, std::tuple<BDifferent, BOther...>>
: subset_of<
std::tuple<ADifferent, AOther...>
, std::tuple<BOther...>
> {};
template<typename... B>
struct subset_of<std::tuple<>, std::tuple<B...>>: std::true_type {};
template<typename... A>
struct Foo {
template<typename... B>
static void bar()
{
static_assert(subset_of<std::tuple<A...>, std::tuple<B...>>::value, "Hello");
}
};
Test case:
struct Apple{}; struct Orange{}; struct Grape{};
int main()
{
Foo<Apple, Orange>::bar<Apple, Orange, Grape>(); // this compiles
Foo<Apple, Orange>::bar<Grape, Apple, Grape, Orange, Grape>(); // this also compiles
Foo<Apple, Orange>::bar<Orange, Grape>(); // this doesn't
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With