Limit the supported template class types with variadic templates

I'm trying to handle classes of image processing operations that are only compatible for certain combinations:

• measurement set [1,2,3, ...]
• set of types [int, float, double, ...]

One working method would be to define a generic templated class that handles the default case (which: does nothing):

template <int dimension, typename dataType>
class IPOperation
{
public:
    void execute()
    {
        std::cout << "do nothing" << std::endl;
    }
};

      

        
        
        
      

    

Then I would have to write a specialization of this class for all supported combinations of types, for example, for example:

template<>
class IPOperation<2,float>
{
public:
    void execute()
    {
        std::cout << "do something" << std::endl;
    }
};

      

        
        
        
      

    

But since the number of supported size / type combinations can get really large, this approach is overkill.

Inspired by political design, it would be nice to equip the template class with certain constraints, something like this:

template <int dimension, typename dataType>
class IPOperation : public supportedDimensions<2,3,4>, public supportedTypes<int, float, double>
{
    void execute()
    {
        std::cout << "execute()" << std::endl;
    }
};

      

        
        
        
      

    

My bad approach so far has been (and it seems pretty bad, I can't help myself):

#include <iostream>
#include <vector>

template <int... supportedDimensions>
class IPDimensions
{
private:
public:
    static std::vector<int> getSupportedDimensions()
    {
        return { supportedDimensions... };
    }

    static bool supportsDimension(int dim)
    {
        std::vector<int> dimensions = getSupportedDimensions();
        return std::find(dimensions.begin(), dimensions.end(), dim) != dimensions.end();
    }
};

template <int dim>
class IPOperation : public IPDimensions<2,3>
{
private:
public:
    void execute(void)
    {
        if(IPOperation::supportsDimension(dim))
        {
            std::cout << dim << "d is supported -> execute" << std::endl;
        }
        else
        {
            std::cout << dim << "d is not supported -> sit down and do nothing" << std::endl;
        }
    }
};

int main(int argc, const char * argv[])
{
    IPOperation<2>* okay = new IPOperation<2>();
    IPOperation<4>* notOkay = new IPOperation<4>();

    okay->execute();
    notOkay->execute();
}

      

        
        
        
      

    

When trying to apply something like this for types, I am completely lost. It would be nice to have some kind of mechanism for doing some checks on how you use policies as delegates for certain strategies. Maybe my approach is wrong and the whole thing could be done much easier with macros, enums or dashes and std :: enable_if to make functions visible only for certain scenarios, but since I spent some time reading some C ++ 11 so, I don't know anything else.

Thanks guys for some helpful advice!