Pattern to specialize templates based on inheritance possible?

Question

So, one problem pattern that I keep coming across and don't have a good solution for is how to provide template specializations that are based in what type a template parameter is derived from. For example, suppose I have:

template<typename T>
struct implementPersist;

template<typename T>
void persist( T& object )
{
   implementPersist::doPersist( object );
}

What I'd like is for users of persist to be able to provide implementations of implementPersist::persist for types that are declared after the above. That's straightforward in principle, but cumbersome in practice but the user need to provide an implementPersist for every type.

To be more clear, suppose I have:

struct Persistent { virtual void myPersist() = 0; };
struct MyClass : public persistent { virtual void MyPersist() { ...implementation...} };

// Persists subclasses of Persistent using myPersist
template<>
struct implementPersist<Persistent>{ void doPersist(Persistent& p) { p->myPersist(); } };

struct X{};

template<>
struct implementPersist<X>{ void doPersist(X& p) { ...implementation...} };


// Persists subclasses of Persistent using boostPersist
struct MyBoostPersistedObject { virtual void boostPersist() = 0 };
struct Z : public MyBoostPersistedObject { virtual void boostPersist() = 0 };

template<>
struct implementPersist<myBoostPersistedObject>{ void boostPersist() { ...implementation... } };

My intention is that I provide one template implementation for all subclasses of Persist, another for all subclasses of myBoostPersistedObject and other for miscellaneous classes not in interesting classes structures (e.g. various POD types). In practice however,

implementPersist<Persistent>::doPersist

is only ever invoked if ::persist(T&) is called where T is exactly a Persistent object. It falls back to the (missing) generic case where T=myClass. In general, I want to be able to specialize templates in generic ways based on inheritance. Its little frustrating because clearly compilers know how to do this, and do it when deciding to call functions based upon parameters, e.g.

void persist( Persistent&); void persist( X& ); void persist( myBoostPersistedObject& );

But as far as I can tell, no such similar matching can be done for templates.

One workaround is to do something like:

class persist;

template<typename T, bool hasMyPersistMethod=isDerivedFrom(T,persist)::value >
struct implementPersist;

template<typename T, bool true >
struct implementPersist<T,true>
{
   template<> struct implementPersist<X>{ void doPersist(T& p) { p->myPersist(); } }
};

(see here for isDerivedFrom).

However, this requires that the initial declaration of implementPersist knows about the types of the classes providing implementations. I'd like something more generic.

I'm frequently finding uses for such a pattern, in order to avoid adding explicit specializations for every class in my system.

Any ideas?

Answer 1

Try using a reference of the base type to refer to the derived type:

MyClass x(...);
Persistent * p = &x;
implementPersist<Persistent> ip;
ip.doPersist(*p);

Answer 2

Yes, you can do this using enable_if.

#include <iostream>
#include <boost/type_traits.hpp>
using namespace std;


template <bool Enable, typename T = void>
struct enable_if
{
    typedef T type;
};

template <typename T>
struct enable_if<false, T>
{
};

template <typename T, typename Enable = void>
struct persist_t {};

struct A
{
    virtual void foo() const = 0;
};

template <typename T>
struct persist_t<T, typename enable_if<boost::is_base_of<A, T>::value>::type>
{
    static void persist(T const& x)
    {
     x.foo();
    }
};


struct B : A
{
    virtual void foo() const { cout << "B::foo\n"; }
};

template <typename T>
void persist(T & x)
{
    persist_t<T>::persist(x);
}

int main()
{
    B b;
    persist(b);
}

Boost has a nicer implementation of enable_if, I just provided it here for completeness. Boost also has an example of using it that is very similar to my above example.

Hope that helps.