Vladimir.Batov@wrsa.com.au wrote:
2. The name of the namespace.
People largely seem content with "boost::string".
[snip]
Therefore, unless something major comes up later we are settling on "boost::string".
Sorry, I still don't think that's a good idea. The problems that were mentioned seem quite real to me, whereas the namespace name can be easily changed to another one without problems. If boost::strings isn't good enough, there was another suggestion - to use the boost::algorithms namespace in the Boost.StringAlgorithms library. Actually, submitting these tools as the StringAlgorithms extension looks quite a viable idea to me.
3. Naming of the conversion functions.
The "to/from/is" set seems to sit well with the majority of people.
The to_string/from_string was floated around as alternatives. I feel that the "_string" extension indeed serves a mildly useful purpose when the "string" namespace is obfuscated. Like
namespace boost::string obfuscated;
string str = obfuscated::from(i); // What the...? string str = obfuscated::to_string(i); // Somewhat better but still...
I must say, this is my case. However, I tend to use acronyms for namespace aliases: namespace bll = boost::lambda; namespace bmi = boost::multi_index; As for this tool, I would probably namespace bsl = boost::string; Then the library usage becomes a mess.
When used sensibly
string str = boost::string::from(i);
That's too lengthy.
or namespace boost::string str; string str = str::from(i);
That's possible, however, str is often used as a variable name. I don't like the idea of messing it with the namespace alias.
the intention seems clear and the following feels like a tautology:
string str = boost::string::to_string(i);
Maybe that's another sign that the namespace name is suboptimal.
4. String-To-Something Conversion Interface.
I think people on the original lexical_cast-realted thread were pretty content with
int i = boost::string::to<int>(str, -1);
syntax. If so, then we won't need
int i = to(str).or_default(-1) int i = to(str, default_ = -1)
I think, "to<int>(str, -1)" does not exclude "to(str, default_ = -1)". I'd like to have both, especially since Boost.Parameter allows it. Then I could have: int i = to< int >(str, -1); int i = to< int >(str, default_ = -1); int i = to< int >(str, radix_ = 16); bool f = to< bool >(str, bool_alpha_ = true); int i = to< int >(str, locale_ = loc, default_ = 100);
6. Something-To-String Conversion Interface.
That did not seem to generate much heat at all. I'll summarize to make sure we see it the same way:
template<class T> boost::string::value<std::string> boost::string::from(T const&) throw();
Does not throw. No default value (do we need one?). Returns string() of failure.
I think, it should be symmetric to the "from-string" conversions and should have the same capabilities, including default values. See my suggestion above.
8. Throw/No-Throw Behavior.
You might have noticed that the interface above *never* throws anything on failure. I would like to highlight the fact (as it's different from lexical_cast behavior) and make sure people are happy with it. Those who need an exception thrown could do
boost::value<int> i2 = boost::string::to<int>(str, -1); if (!i2.good()) throw something youself;
Is it satisfactory?
Aside from symbol names, looks acceptable to me.