Re: [boost] [convert] Now with Boost.Parameter interface.

4 Jul 2009

      Hi,
----- Original Message ----- 
From: "Gottlob Frege" <gottlobfrege@gmail.com>
To: <boost@lists.boost.org>
Sent: Thursday, July 02, 2009 6:55 PM
Subject: Re: [boost] [convert] Now with Boost.Parameter interface.

On Thursday, July 2, 2009, Scott McMurray <me22.ca+boost@gmail.com> wrote:
...
2009/7/2 Stewart, Robert <Robert.Stewart@sig.com>:
...
Why not with the syntax Dave has been suggesting:
converter<int>(locale_ = loc, throw_ = true).from(str, 0);
To me, that's the nicest one yet proposed.
I think that the only complaint was that it limits the number of
params, whereas the other version does not. But if you have more than
10 params, I think you have bigger problems.
...
And it'd be quite reasonable, instead of statics, to just use
I didn't see that as a static, but as a constructor call.
...
convert<int>().from(str, 0), since that's already common from function
objects.
And actually, why not spell from() as operator(), so it can be a
proper function object?
transform( istream_iterator<string>(cin), istream_iterator<string>(),
back_inserter(v), convert<int>(locale_ = loc, base_ = 16, throw_ =
false, default_ = 0));
I have followed this thread and I would like to share with you my view. IMO we need a converter function and a convert free function that returns the To type. With the interface below we should be able to 

* make a conversion using a default converter (which could throw if the conversion fails)

int i = convert<int>(str);

* make a conversion using a specific converter constructed form these coverter parameters

int i=convert<int>(str, (locale_ = loc, base_ = 16, throw_ = false, default_ = 0));

Note that we can also have

int i=convert<int>(str, (locale_ = loc)(base_ = 16)(throw_ = false)(default_ = 0));

if the converter_parameters defines the operator().

* transform using a converter functor

transform( istream_iterator<string>(cin), istream_iterator<string>(),
back_inserter(v), converter<int>((locale_ = loc, base_ = 16, throw_ =
false, default_ = 0)));

The class converter_parameters is used to store all the parameters related to the conversion. It should be close to the internal representation of the current converter convert_detail::implementation<TypeIn, TypeOut> but without the TypeIn 

template <typename To>
class converter_parameters {
...
}

The converter class is the functor class realizing the conversion using the conversion parameters
template <typename To>
class converter {
    converter();
    converter(converter_parameters<To> const&);
    template <typenam From> To operator()(From);
};

the convert function now return the out type  (To) and not a converter

template <typename To, typename From>
To convert(From f, converter<To> const&cv) { 
    return cv(f);
}

template <typename To, typename From>
To convert(From f, converter_parameters<To> const&cvp) { 
    converter<To> cv(cvp);
    return convert(f, cv);
}

template <typename To, typename From>
To convert(From f) {
    converter<To> cv;
    return convert(f, cv)
}

I dont' think the current implementation needs to much changes to be adapted to this proposal.

HTH,
Vicente

Re: [boost] [convert] Now with Boost.Parameter interface.

vicente.botet