#include <iostream>
#include <ntpm++/conditional_interface.h>



template <class TT> class Container;

template <class T>
class Add_forwarder
{
public:    Container<T> &add(const Container<T> &a) { return _add(a); }
private:   virtual Container<T> &_add(const Container<T> &a) = 0;
};
template <class T>
class Mult_forwarder
{
public:    Container<T> &mult(const Container<T> &a) { return _mult(a); }
private:   virtual Container<T> &_mult(const Container<T> &a) = 0;
};

template <class T>
class Container : public COND_INTERFACE<T::CanAdd, Add_forwarder<T> >::V,
                  public COND_INTERFACE<T::CanMult, Mult_forwarder<T> >::V
{
public:
    // the add and mult methods will be inherited and accessible as a
    // public member if T satisfies the requirements
private:
    virtual Container<T> &_mult(const Container<T> &a)
    {
	cout << "mult implemenetation\n"; return *this;
    }
    virtual Container<T> &_add(const Container<T> &a)
    {
	cout << "add implementation\n"; return *this;
    }
};


struct T_HasAdd_NoMult {
    enum {CanAdd=1, CanMult=0};
};

struct T_NoAdd_HasMult {
    enum {CanAdd=0, CanMult=1};
};


int main()
{
    Container<T_HasAdd_NoMult> ob1c, ob1cc;
    Container<T_NoAdd_HasMult> ob2c, ob2cc;

    ob1c.add(ob1cc);
    ob2c.add(ob2cc);

    ob1c.mult(ob1cc);
    ob2c.mult(ob2cc);
}