Order independant variadic template arguments - c++

Question

I want to create a system of "Mapper", i.e objects that takes an input (template) value and return a output (template) value. A mapper can have additional features / traits.
Sample code :
// a trait
template <typename I, typename O>
class Writable
{
public:
virtual ~Writable() = default;
virtual O & operator()(I i) = 0;
};
// another trait
template <typename I, typename O>
class Bounded
{
public:
virtual ~Bounded() = default;
virtual O min() const = 0;
virtual O max() const = 0;
};
// base class
template <typename I, typename O, template<typename, typename> class ... Traits>
class IMap
: public Traits<I, O>...
{
public:
virtual ~IMap() = default;
virtual O operator()(I i) const = 0;
};
// a test mapper
class Test1
: public IMap<int, double, Writable, Bounded>
{
public:
double operator()(int i) const override { return _d; }
double & operator()(int i) override { return _d; }
double min() const override { return 0; }
double max() const override { return 1; }
private:
double _d;
};
// another test mapper
class Test2
: public IMap<int, double, Bounded, Writable>
{
public:
double operator()(int i) const override { return _d; }
double & operator()(int i) override { return _d; }
double min() const override { return 0; }
double max() const override { return 1; }
private:
double _d;
};
// a class to use mappers
template <typename I, typename O>
class MapUse
{
public:
// I would like this function to accept an IMap containing "at least" the Bounded trait
// Ideally this function signature should be like
void method_requiring_writable(IMap<I, O, Bounded> & map)
{
map(123)
map(123) = 0;
}
// I would like this function to accept an IMap containing "at least" the Bounded and Writable traits
// (no matter the actual order of those traits in variadic template parameter )
// Ideally this function signature should be like
void method_requiring_bounded_and_writable(IMap<I, O, Bounded, Writable> & map)
{
map(123);
map(123) = 0;
map.min();
}
};
void test()
{
Test1 t1;
Test2 t2;
Test2 * p = dynamic_cast<Test2*>(&t1); // << always return nullptr, of course !
MapUse<int, double> mu;
mu.method_requiring_writable(t1); // << does not compile, not the right type
mu.method_requiring_bounded_and_writable(t1); // << does not compile, not the right type
return;
}
Error at line : mu.method_requiring_writable(t1) :
error C2664: 'void MapUse<int,double>::method_requiring_writable(IMap<I,O,Bounded> &)': cannot convert argument 1 from 'Test1' to 'IMap<I,O,Bounded> &'
> with
> [
> I=int,
> O=double
> ]
Error at line : mu.method_requiring_bounded_and_writable(t1) :
error C2664: 'void MapUse<int,double>::method_requiring_bounded_and_writable(IMap<int,double,Bounded,Writable> &)': cannot convert argument 1 from 'Test1' to 'IMap<int,double,Bounded,Writable> &'
I perfectly understand why this does not work, but I would like a "trick" to make it work !
First problem : Order of traits in variadic template parameter does count. It should easily be solved by forcing the developer to respect traits order, but it's not ideal
Second problem : Be able to create methods that requires a mapped with "at least" a specific set of traits. No clue about this one.
First approach was not variadic, but a - very - complex hierarchy with lots of virtual heritage --> ugly as hell, it's a real pain to add a new trait
With the code above, I thought about adding some kind of cast operators in IMap but failed to do so.
Any C++ / variadic / magic stuff specialist to help on this ?

Answer 1

You can use something like this:
#include <type_traits>
template <template <class, class> class... Traits,
std::enable_if_t<
std::is_base_of<Bounded<I, O>, IMap<I, O, Traits...>>::value
and std::is_base_of<Writable<I, O>, IMap<I, O, Traits...>>::value
, int> = 0>
void method_requiring_bounded_and_writable(IMap<I, O, Traits...> & map) {
// Do stuff
}

Answer 2

Why do you wan't to check the mixed-in types in the first place? You are mixing generic and non-generic programming here. Simply use the implemented traits (like min() and max()) and forget about how they were implemented. A straight-forward and clean solution is to simply continue using generic programming:
//template <typename I, typename O>
class MapUse {
public:
template <typename T>
void method_requiring_writable(T& map) {
map(123);
map(123) = 0;
}
template <typename T>
void method_requiring_bounded_and_writable(T& map) {
map(123);
map(123) = 0;
map.min();
}
};
Other solutions require heavy meta-programming and only make your code more complex and hard to read. I understand that this might not solve your very specific problem. This is an advise to rethink your design and fully jump on the generic train or drop it altogether.