Re: [boost] any_function (callback) library

From: Doug Gregor (gregod_at_[hidden])
Date: 2001-04-09 22:05:36

On Monday 09 April 2001 03:43, you wrote:
> At Mon, 9 Apr 2001 08:42:48 -0400,
>
> Doug Gregor wrote:
> > ------------------------------
> > Interface summary:
> >
> >   template<typename Result, typename Arg1, typename Arg2, ..., typename
> > ArgN> class any_function
> >   {
> >     any_function();
> >     any_function(const any_function&);
> >     template<typename Functor> any_function(Functor);
> >     ~any_function();
> >
> >     any_function& operator=(const int);  // assignment to zero clears
> > target template<typename Functor> any_function& operator=(Functor);
> > any_function& operator=(const any_function&);
> >
> >     void clear(); // clear out the target
> >
> >     bool empty() const; // true if no target
> >     operator const void*() const; // evaluates true if non-empty
> >
> >     Result operator()(Arg1, Arg2, ..., ArgN); // call target
> >   };
> > -------------------------------
> >
> > 	Doug
>
> Here are my two cents:
>
> Could be there is speicalized versions of any_function class which
> take a function pointer type template argument and deduce other types
> from it ?

It is possible, though I don't know that it could be done portably because it 
would (likely) require either partial specialization (not always available) 
or a working is_function (I don't believe is_function works on all platforms).

> template <class Fp>
> class any_function<function_traits<Fp>::return_type,
> 	           function_traits<Fp>::Arg1,
> 	           function_traits<Fp>::Arg2,
> 	           ...>
> {
>   any_function(Fp fp_);
>
>   //...
> }

I'm not entirely sure what you are getting at here. The above template can't 
ever be selected because all of the parameters used in the specialization 
(i.e., typename function_traits<Fp>::return_type) can't deduce Fp. 

> Or maybe a set of functions:
>
> template <class Fp>
> function_traits<Fp>::return_type
> eval_function(Fp fp);
>
> template <class Fp>
> function_traits<Fp>::return_type
> eval_function(Fp fp, function_traits<Fp>::Arg1 arg1);
>
> template <class Fp>
> function_traits<Fp>::return_type
> eval_function(Fp fp, function_traits<Fp>::Arg1 arg1,
> function_traits<Fp>::Arg2);
>
> //more to take more arguments.
>
>
> In fact, I am using the latter to create threads in my code.

What additional power do the eval_function functions give you over just:

Fp fp;
fp(arg1, arg2, ..., argN);

?

I can see some usefulness of, for instance, a "make_function" helper function 
that is defined as:

template<typename R, typename T1, typename T2, ..., typename TN>
any_function<R, T1, T2, ..., TN>
make_function (R (*f)(T1, T2, ..., TN)) { /* ... */ }

But even in this case, would it be more useful just to pass the original 
function (object/pointer)?

        Doug