Subject: Re: [boost] [convert] Now with Boost.Parameter interface.
From: vicente.botet (vicente.botet_at_[hidden])
Date: 2009-07-04 16:23:30
Hi,
----- Original Message -----
From: "Gottlob Frege" <gottlobfrege_at_[hidden]>
To: <boost_at_[hidden]>
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_at_[hidden]> wrote:
> 2009/7/2 Stewart, Robert <Robert.Stewart_at_[hidden]>:
>>
>> 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