[boost] Any interest in dynamic dispatching mechanism from "interface" to template functions ?

Subject: [boost] Any interest in dynamic dispatching mechanism from "interface" to template functions ?
From: Raffi Enficiaud (raffi.enficiaud_at_[hidden])
Date: 2010-07-01 06:32:02

Hello all,

The idea behind is not new and consists in dispatching a call of an  
interface function to the correct template instance, depending on the
runtime or compile time parameters. The field of application is (to  
me) the release of static/dynamic libraries including functions with a  
predefined
set of types combination. This way, the library (compiled once) can  
easily be plugged to another framework or a script program (I  
personally use it with boost.python).

An example of use could be (general idea, not a real code of course):
// --------------

template <class real_type>
int template_function(real_type const& r_class1, double param_d, int&  
param_out)
{
   // ...
   return 0;
}

int interface_function(MyInterface const* i_class1, variant const&  
param, variant& out)
{
   // return value
   int return_value;

   // constructs the dispatcher object with a reference to the values  
passed to interface_function
   dispatcher<int, MyInterface const*, variant const&, variant&>  
dispatch_object(return_value, i_class1, param, out);

   bool res = dispatch_object.calls_first(
       fusion::vector_tie(
         template_function < class_t1 >,
         template_function < class_t2 > //...
         )
       );
   if(res) return return_value;
   return -1;
}

// --------------

The dispatch_object tests for the convertibility of each instance ui  
of the arguments Ui of the interface function, with the corresponding  
argument Ti
of the template function. The type of matching is defined by external  
objects, with a simple interface providing two methods: a  
convertibility test and a conversion.
The types are "cleaned" in order to have a limited number of  
conversion structures.

Currently this mechanism is used in a generic image processing  
library. The images have all the same virtual interface and the  
dispatch calls
the correct template function based on the concrete type of the image.  
It also includes a "back conversion" for Ui's that are non-const  
reference or pointers.
The dispatch mainly makes use of boost.fusion, boost.mpl and  
boost.function_types.

I have checked a little bit the Boost.Vault but, correct me if I am  
wrong, the current dispatching mechanisms do not address exactly this  
issue.
The code is already open-source released under the boost license. I  
can put some samples in the Vault if there is any interest.

Your comments are very welcome !
Kind regards,
Raffi Enficiaud