Boost logo

Boost :

Subject: Re: [boost] Boost.Convert+Boost.Parameter
From: Vladimir Batov (batov_at_[hidden])
Date: 2009-02-28 03:22:08

> "Andrey Semashev" <andrey.semashev_at_[hidden]> wrote
> convert< string >((param1 = val1, param2 = val2, ...));


I started playing with your example integrating it in to the conversion
framework and managed to get it working. Thank you for the example and that
parameter_type extension. The whole thing seems to rely on that facility.
Well, the interface I am using (without Boost.Parameter) is

    int i = convert::to<int>(str);
    int i = convert::from(str, -1);

(almost what I initially started from :-) ) I tried to get rid of 'to&from'
(several times) but in the end decided I needed to keep the two variations
as the 'from' deduces both (TypeIn, TypeOut) parameters from the signature
when the 'to' requires TypeOut explicitly specified. Having both named
convert() reads wrong for the 'to' specialization:

    int i = convert<int>(str);

and I could not stand it. Another option would be to ditch 'to' altogether
but I am not sure how it might be taken. Also I tried deducing TypeOut
parameter for 'to' as well via

template<class TypeIn>
    template<class TypeOut> operator TypeOut()

but did not get too far either.

Well, I digressed from my original post about Boost.Parameter as I did not
want us to get bogged down with convert::to and convert::from again (and BTW
you cannot shortcut them so they are very much like convert_to,
convert_from). OK. What I got working (thanks to your help) is

    int i = convert::to<int>(str, radix_ = 10);
    int i = convert::from(str, default_ = -1);
    int i = convert::from(str, (default_ = -1, radix_ = 10));

I understand the benefits of passing additional conversion parameters like
'radix_ = 10' down to the conversion *implementation*. However, I feel these
parameters are of no value (and not accessible) to the "casual" user (as
opposed to the conversion implementer)... unlike I/O Stream-based approach
which allows the user to write his own manipulator and deploy it like

    int i = convert::from(str, -1) >> my_special_formatter;

Is my understanding correct or you have some ideas of getting that *user*
extensibility with Boost.Parameter?

Secondly, I kinda like the explicitness of

    int i = convert::from(str, default_ = -1);

however, does it really add much (apart from verbosity) compared with

    int i = convert::from(str, -1);

I do not feel the above line is the trickiest in the whole Boost so that we
need to get out of our way to spell out every damn thing. What do you think?
That leads me to my question. Would that be sensible to have it as follows:

    int i = convert::to<int>(str, (radix_ = 10, locale_= ...));
    int i = convert::from(str, -1, (radix_ = 10, locale_= ...));

or you might have something else in mind?


Boost list run by bdawes at, gregod at, cpdaniel at, john at