April 2011 - Boost - lists.boost.org

[locale] Formal review of Boost.Locale library -- final days
by Chad Nelson 22 Apr '11

22 Apr '11

The final day of the Boost.Locale formal review is tomorrow, April 22nd. If you're planning to submit a review but haven't, now is the time. I'll accept reviews up until I complete the report on Saturday morning. Writing a review ================ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager (me). Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. -- Chad Nelson Oak Circle Software, Inc. * * *

6 7

Re: [boost] Boost statechart viewer
by Christophe Henry 22 Apr '11

22 Apr '11

> I have no plan about Boost::MSM library in next two months. From the > first point of view I think that it shouldn't be difficult to update > the program to be able to work with Boost::MSM. So maybe after or > during summer holidays. > > If I do anything I will let you know. Hi Petr, If you decide to support MSM, I'll be happy to provide help if you need. Regards, Christophe

1 0

Fwd: Submission for Google Summer of Code 2011
by Suriya Singh 22 Apr '11

22 Apr '11

Project proposal: A lightweight platform independent library for graphics for Android. Start Date: 10 june 2011 Start Coding 10 june 2011 Documentation 1 August 2011 Testing: 25 July 2011 End date: 10 August 2011

1 0

[Foreach] Supporting range adaptors for temporary containers
by Michel MORIN 22 Apr '11

22 Apr '11

Sometimes it is convenient to apply range adaptors to a temporary container and iterate over it: // `using namespace boost::adaptors;` is assumed BOOST_FOREACH(auto x, std::string("Hello, world!") | reversed) {...} However, the lifetime of the temporary container ends before the loop body begins. This problem also exists in C++0x range-based for. To solve this, I'd like to propose an extension of BOOST_FOREACH macro: BOOST_ADAPTED_FOREACH(VARIABLE, RANGE, ADAPTORS) { // do something } which is conceptually equivalent to { auto const& rng = RANGE; // if RANGE is an lvalue, use `auto& rng = RANGE` BOOST_FOREACH(VARIABLE, rng | ADAPTORS) { // do something } } A temporary range, RANGE, is bound to a const reference and its lifetime is extended. (To do this, compiler support of rvalue references and `auto`/ `decltype` is needed. In C++03, a temporary range needs to be copied.) Then we can do the following without worry about the lifetime problem. BOOST_ADAPTED_FOREACH( char ch , std::string("Hello, world!") , reversed | replaced('e', 'a')) { std::cout << ch; } To bind a temporary range, we can also use (non-const) rvalue reference. But I choose to use const lvalue reference. The rationale is * In the pipe operator, a temporary range is captured as a const reference. So if we use rvalue reference binding, the mutability of the resulting range (`auto&& rng = RANGE; rng | ADAPTORS`) and `RANGE | ADAPTORS` would be different. For example, `std::list<int>(3) | reversed` is a const range, but `auto&& rng = std::list<int>(3); rng | reversed` is a mutable range. To be consistent with `RANGE | ADAPTORS`, using const lvalue reference (`auto const& rng = RANGE; rng | ADAPTORS`) is better. * Mutable iteration over temporary ranges makes little sense. Note that, BOOST_ADAPTED_FOREACH works fine if an input range is a temporary containers, but it does not work properly if an input is a range-proxy (such as `iterator_range`) of a temporary container. In this case, only the lifetime of range-proxies is extended and dangling reference to the temporary range occurs: BOOST_ADAPTED_FOREACH( int i , boost::equal_range(std::multiset<int>(...), 1) , reversed) { // Oops, dangling reference! // Input is an `iterator_range` of the temporary multiset<int>(...) } BOOST_ADAPTED_FOREACH( int i , boost::assign::list_of(1)(2)(3)(4)(5) , reversed) { // Oops, dangling reference! // Input is a reference to the temporary `list_of(1)` } Header file and sample code attached. (Though I omitted the C-string support for simplicity, it is easy to add the support.) If there are some interests about this proposal, I will create a trac ticket. Comments? Regards, Michel

3 5

[locale] Review
by Mathias Gaunard 21 Apr '11

21 Apr '11

Let us start with my decision: I vote against inclusion of Boost.Locale into Boost in its current state, but strongly encourage the author to reconsider resubmitting it after some design issues have been reconsidered. In which case, I would be in favour of putting it on the fast-track for a mini-review. Since I am the author of another Unicode library that I'd like to see included in Boost, I hope that my review will not be considered biased. I believe Boost.Locale is a valuable and useful library, and I believe both libraries can coexist. The main reason for my decision is the interface that the library provides: albeit it aims at abstracting the backend used to implement the facilities, it exposes too much of how those facilities are implemented, which prevents benefiting from future backends that may not have the same limitations as the current backends do. Indeed, the Boost.Locale rationale clearly says that it only takes std::basic_string and const char* as input because that's what the backend libraries expect anyway. Yet there are various scenarios where this is useful: - I might want to apply some operation to data in a file without putting it all to memory first; Boost.Locale could copy that memory by chunks to apply that operation for backends that have no native support for this. Copying the whole file to memory is a good enough approximation for a first version. - The input I have may not be directly available in the form of a contiguous buffer, but I wouldn't mind if Boost.Locale copied it. If we consider the functions from_utf, to_utf and between, they can either take a const char*, two const char*, or a std::basic_string. Clearly this would be better if those functions took a range, which covers all three of these cases. It's not just a matter of being generic, it makes the library easier to use since the range is defined by a single argument which can be anything I want, I do not need to convert to what the library needs. If the library needs to do conversion behind the scenes, it can do it just like that, behind the scenes. Taking a range causes the problem however of what the return type should be: I think there should be two variants, one which returns a string, and one which appends to a container (like Boost.StringAlgo) or write to an output iterator (like STL algorithms). Obviously, the former would be defined in terms of the latter. This causes however a big problem: all backends would not be interchangeable with a stable unique ABI. Maybe some template specializations could be injected at link-time, but they would have to be full concrete specializations. Maybe the idea of backends being interchangeable at the ABI level needs to be rethought. After all, isn't being interchangeable at the API level enough, since you can easily mangle the configuration in a symbol to cause an error if linking with the non-matching backend? Still talking about conversion between encodings, I would like it if it was possible to statically choose the encodings we're converting between, as some backends could directly expose a specialized and optimized some_encoding_to_some_other_encoding function. Note the remarks about conversion between encodings also applies to case folding, collation etc. Being able to specify statically the normalization form you're normalizing to and things like that could be useful just as for the character encodings. Perhaps not made clear from the docs, but Boost.Locale embeds another mechanism than the functions in the conv namespace to convert between character encodings: using the classes derived from boost::locale::util::base_converter. This is the only interface that can be passed incomplete data, as obtained through buffering. That interface was designed to implement codecvt facets, and unfortunately, it's not much better. The library implements its own UTF-8/UTF-16/UTF-32 conversion logic there regardless of which backend is used; it is a shame it cannot reuse the to_utf or from_utf functions in all cases. This implementation is also quite tricky since the state management prevents the code from being simple and self-contained. That interface does not allow optimized conversion functions to be used. Compatibility with codecvt facets is a nice feature, but it shouldn't impair the interface of the component that could have other usages. Furthermore, I do not find the boundary analysis interface satisfying at all. It is not made clear in the docs that doing boundary analysis actually goes through the whole string and returns a vector of positions corresponding to the boundaries. You can use that vector to adapt any range into a range of strings. Each dereferencing copies the subrange defined by the vector into a new temporary string. This is pretty terrible. I want to be able to find the boundaries as I advance through a string, or be able to find the closest boundary from an arbitrary position without having to process the whole string. I do not want to have to copy my whole input range into little strings for no reason. Usage of this feature is also unnecessarily verbose. It should not be more than a function call to turn a range of characters into a range of tagged ranges of characters. This part of the library is the one that needs the more work. Ironically enough, it's also the only one that deals a bit with iterators and ranges, and I just asked for more iterators and ranges at the beginning of this review ;). Finally, I will not comment on the implementation too much, since I think other Boosters already did that (though I did not read all of it). There is some unnecessary or non-optimal code, some code more complicated than it should be, some compile-time values tested at runtime, some things that could have reused existing utilities from Boost, and some inappropriate use of reinterpret_cast. While most of the backends are separated, it is not the case for encoding/codepage.cpp, which is shared by all backends and contains ifdefs. This is not a very nice extension point. I'm also a bit concerned about the generalized usage of virtual functions anywhere; it seems unnecessary in quite a few places, please prefer using templates when dynamic binding is not required. A lot of new and vectors too, I'd prefer if ideally the library never allocated anything. I hope my review will be well received and that you will consider all of my "feature requests". Your library is practical and can get things done for sure, but maybe it's not quite as good as it could be in terms of interface yet. Also, if I want Boost.Unicode to ever be a possible backend, Boost.Locale needs to be able to make the most of it ;).

8 18

[Review] Formal review of Boost.Convert library starts Saturday
by Edward Diener 21 Apr '11

21 Apr '11

This is a reminder that formal review of the Boost.Convert library by Vladimir Batov starts on Saturday, April 23, and is scheduled to last through May 2. *************** * Its Purpose * *************** From the introduction: Boost.Convert builds on the boost::lexical_cast experience and still offers a simple, minimal interface, familiar conversion behavior and more: * throwing and non-throwing behavior when conversion fails; * support for the default/fallback value to be returned when conversion fails; * two types of the conversion-failure check - basic/simple and better/safe; * formatting support based on the standard std::streams and std::stream-based manipulators (like std::hex, std::scientific, etc.); * support for different locales; * support for boost::range-compliant char and wchar_t-based string containers (std::string, std::wstring, char const*, wchar_t const*, char array[], etc.); * no DefaultConstructibility requirement for the Target/Destination type; * extendibility and additional room to grow. ******************* * Where to get it * ******************* You can find the Boost.Convert here: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-… The HTML documentation is part of the distribution and can be found at libs/convert/index.html in the distribution above. ******************** * Writing a review * ******************** The reviews and all comments should be submitted to the developers list, and the email should have "[convert] Review" at the beginning of the subject line to make sure it's not missed. Please explicitly state in your review whether the library should be accepted. The general review checklist: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Edward Diener, Review Manager

1 0

GSoC 2011
by mahbubul hasan 21 Apr '11

21 Apr '11

Hi, I am Mahbub. I am a CSE graduate. I just saw you had a proposal regarding queue and heap in GSoC 2010. In my undergraduate I did thesis on heaps. In that time I learned soft heap, it might be interesting to you. Here is the short description of soft heap<http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.85.3258&rep=rep1&t…>.( http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.85.3258&rep=rep1&t…) Soft heap is a heap like data structure but with some uncertainty. This data structure supports insert, delete, merge, findmin. It does every work in amortized constant time except insert operation which takes O( log 1/e ) where 0<e=<.5. Here e is error rate. The data structure will never contain more than en corrupted elements. There are two versions of soft heap. 1. By Binomial Tree 2. By forest of binary tree There is one more thing that might interesting to you. That is, in my undergraduate I improved the running time of heap sort by significant amount by applying pairing technique. The paper is submitted to International Journal of Computer Mathematics and it is under review now. It mainly improves Carlsson's variant of heapsort. It also improves the deletion method proposed by Gonnet and Munro (Heaps on Heaps). [The heap is inplace, that means no additional space is required] It also improves the Weak Heapsort. WeakHeapsort is a sorting method which requires O(n) additional bit to sort. However applying the pairing technique it can be reduced to O(n/2) additional bit. It is known that weakheap is the theoretically best known algorithm. [Best considering number of comparisons] So I am just curious if you are interested in these types of algorithms. I saw no possible proposal category where these fits in, but I thought you might be interested. Please let me know what do you think about this. Mahbub

2 6

[locale] Formal review of Boost.Locale library EXTENDED
by Chad Nelson 21 Apr '11

21 Apr '11

(This message made it to the announcements list, but the copy intended for the developers list didn't make it and I hadn't noticed. I apologize if this inconvenienced anyone.) There have been only a handful of reviews of the proposed Boost.Locale library to date, and several people have requested more time to provide theirs, so the formal review of the Boost.Locale library has been extended. The deadline for reviews is now 11:59pm UTC on Friday, April 22nd. For those in the Western hemisphere, remember that that's earlier than it might seem -- 7:59pm in New York, 4:59 in Los Angeles. I'll accept late reviews until I complete the report on Saturday morning, but please try to get yours in earlier. You can find the "boost_locale_for_review" version here: https://sourceforge.net/projects/cppcms/files/boost_locale/ The HTML documentation can also be seen at: http://cppcms.sourceforge.net/boost_locale/html/index.html Writing a review ================ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager (me). Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. -- Chad Nelson Oak Circle Software, Inc. * * *

11 34

review needed
by Xu Sun 20 Apr '11

20 Apr '11

Hi, I've posted my proposal on 04/05 but still didn't receive any reply including email or comment. I will be very appreciated if any one can give me any feedback about my proposal. The link is here: http://www.google-melange.com/gsoc/proposal/review/google/gsoc2011/sunbow/1 Sorry to bother others. Thanks, Xu Sun

4 4

new operator traits: how to merge to the trunk?
by Frédéric Bron 20 Apr '11

20 Apr '11

Dear developpers, I am working on answering all comments of the review concerning the addition of operator traits. When this is finished, what will be the process to include the extension to the trunk? Is it something I will have to do my-self? If so, what is the way to do it? Thanks in advance, Frédéric

2 1