Re: [boost] [announce] Multi signature boost::function v1.0

From: Marco Costalba (mcostalba_at_[hidden])
Date: 2008-05-13 02:50:46

On Mon, May 12, 2008 at 6:39 PM, Giovanni Piero Deretta
<gpderetta_at_[hidden]> wrote:
>  >
>  >  I have written fast, probably there is a better way, but just to show
>  >  the idea. Is this what you mean ?
>
>  Not sure if the code would compile, but, yes, that would be the idea,
>  except for the fact that in my ideal world
>  MSF would have single copy of F.
>

I was able to implemented in my private trunk the recursive
assignment, called set_all() in a much simpler way than the above, due
to how MSF is structured. Indeed the set_all() code ends up to a
couple of very trivial lines:

template<typename Fun>
void set_all(Fun const& fun)
{
     boost_fun = fun;
     Base::set_all(fun);
}

If you want I can send you the new msf.zip code directly, or do you
prefer I update the Vault file ? msf-1.0 -> msf-1.1 ?

BTW also the problem of extra copy of boost::function is fixed.

>
>  >
>  >  > I think that in your case, using
>  >  > operator= is confusing because you are not really reassigning the MSF but
>  >  > just adding an overload. What if operator= tries to bind all signatures at
>  >  > once (and thus allows for boost::function like adaptability) and operator+=
>  >  > (or an explicit add member function) is strict and allows to replace a single
>  >  > overload?
>  >
>  >  operator+= is a nice idea, like an explicit set() or add() method. I
>  >  have been stick to operator=() just to follow boost::function API, but
>  >  I agree in case of MSF this could be confusing...
>  >
>
>  Well, in boost::function, operator= replaces the content of the
>  function, which is
>  not true in MSF case.

In MSF it's true only for functions with same signature:

int foo1(char);
int foo2(char);

f = foo1;

f('x'); // foo1 is called

f = foo2; // foo2 overwrites foo1 as does boost.function

f('x'); // now foo2 is called

>Operator+= might qualify as operator abuse, so
>  an explicit
>  set or add would be better  (but personally have no strong opinion on this)
>

Well set() is already implemented and it works also with the msf code
you (probably) have downloaded. It is just that is not a documented
API. This is because boost.function that used to have set(), has
discouraged and then removed that API.

BTW MSF implementation _really_ needs set() and not only operator=(),
because for SFINAE to work I need an additional (hidden) argument for
each assignment call. Indeed if you look at overload.hpp, operator=()
implementation is just:

template<typename Fun>
function& operator=(Fun const& f)
{
   this->set(f);
   return *this;
}

And set() is a public method so it is usable directly by the user.

>
>  Not sure of what you cannot parse, so I'll try to be as explicitly as possible.
>

Thanks for your explanation, I will comment on this in a separated e-mail

Thanks
Marco