Question

I have a template class, say:

template<class T>
class someClient
{
void someCallbackA() {foo_->onA();}
void someCallbackB() {foo_->onB();}

private:
T* foo_;
};

which I can instantiate with a bunch of different types T which support the onA and onB interface. I happen to have a case where two out of the several different types T I use needs a particular behavior controlled from someClient so I need to add some function doBar() to these two types (call them Edge1 and Edge2). Then I want a part of the someClient code to call foo_->doBar() but without breaking when the type of foo_ does not have that. Is there a way to use boost::enable_if to have a someClient::doBar() which will call foo_->doBar() only for those two types, but not be there, or expand to nothing if the types are not Edge1 or Edge2?

I was thinking along the lines of:

template <class T, enable_if<mpl_or<is_same<T,Edge1>, is_same<T,Edge2> > >
someClient<T>::doBar() {foo_->doBar();}

Answer 1

I think this does what you want. I used C++11 <type_traits> instead of boost’s:

struct Edge {
    void doBar() { std::cout << "did Bar."; }
};

template<typename T>
class someClient
{
public:

    template<typename U = T>
    typename
    std::enable_if<std::is_same<U, Edge>::value, void>::type
    doBar() { foo_->doBar(); }

    template<typename U = T>
    void doBar( typename std::enable_if<!std::is_same<U, Edge>::value, void>::type* = 0 )
    { /* do nothing */ }


private:
    T* foo_;
};

int main()
{
    someClient<int> i;
    someClient<Edge> e;
    i.doBar();
    e.doBar();  // outputs "did Bar."
}

doBar() needs to be template itself for this to work, explanation here: std::enable_if to conditionally compile a member function