September 2009 - Boost - lists.boost.org

PropertyTree automated tests
by Sebastian Redl 04 Sep '09

04 Sep '09

Hi, There are no test results at all for the proptree library on trunk. There isn't even a row in the table for it. Why is that so? Sebastian

2 2

wait-free fast-pathed, bounded-time, 100% starvation-free rw-mutex...
by Chris M. Thomasson 04 Sep '09

04 Sep '09

I was wondering if the following invention of mine might be of use to Boost: http://software.intel.com/en-us/forums/intel-threading-building-blocks/topi… (please __read_all__; thank you) Here are some performance numbers wrt my algorithm versus NPTL on Linux (fedora 10), and OpenSolaris: http://groups.google.com/group/comp.programming.threads/msg/3e7531657a11baf0 My invention has some very interesting properties that simply do not exist for 99% of all the other rw-mutex algorithms I have seen to date. It's 100% starvation free and has bounded wait time for readers and writers. Heck, even the Microsoft rw-mutex algorithm in Vista does not come close to that: http://msdn.microsoft.com/en-us/library/aa904937(VS.85).aspx They clearly state that their algorithm is not fair. The algorithm I have observed in OpenSolaris does not meet this goal as well. Another nice property is that the algorithm has wait-free fast-paths. If readers hit a fast-path, then they are going to get wait-free access to the protected data-structure. The same goes for writers. The underlying operation is a single atomic fetch-and-add operation: http://software.intel.com/en-us/forums/intel-threading-building-blocks/topi… In fact, the algorithm only needs fetch-and-add; no stupid CAS-loops are required. Please take not that there are absolutely no loops in the algorithm; this is one reason why it's bounded time and starvation free. Also, it has conditional reader-to-writer upgrades and non-conditional writer-to-reader downgrade capabilities. This is something that does not exist in the Microsoft implementation, or even the OpenSolaris, or basically any Linux implementation I have observed. Same goes for OSX. Therefore, I think this particular algorithm might be of use to Boost. Any thoughts? Thank you all for you're valuable time; I really do appreciate it! :^)

4 14

1.40 regex
by Jonathan Brannan 04 Sep '09

04 Sep '09

I have code that comes out clean in 1.39 (as unit-test and under valgrind), but under 1.40 it's not clean in valgrind and it crashes when run normally (malloc(): memory corruption). I'm trying to write a reproducer that is smaller than what I have, but incase something pops out at someone (or can point me where my code might be wrong), here is the valgrind output: Running 16 test cases... ==25074== Invalid write of size 8 ==25074== at 0x4E7D4A8: boost::shared_ptr<boost::re_detail::named_subexpressions_base<char> >::shared_ptr() (shared_ptr.hpp:182) ==25074== by 0x4E813C1: boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char cons t*, std::string> > > >::match_results(std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > const&) (match_results.hpp:77) ==25074== by 0x5811371: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator <char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::construct_init(boost::basic_regex<char, boost::regex_traits<char, boost::cpp_rege x_traits<char> > > const&, boost::regex_constants::_match_flags) (perl_matcher_common.hpp:73) ==25074== by 0x4E856D2: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator <char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::perl_matcher(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::_ _normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_i terator<char const*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, _ _gnu_cxx::__normal_iterator<char const*, std::string>) (perl_matcher.hpp:366) ==25074== by 0x4E8583A: bool boost::regex_search<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterat or<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char c onst*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, __gnu_cxx::__no rmal_iterator<char const*, std::string>) (regex_search.hpp:55) ==25074== by 0x4E85BEF: boost::regex_token_iterator_implementation<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex _traits<char> > >::init(__gnu_cxx::__normal_iterator<char const*, std::string>) (regex_token_iterator.hpp:109) ==25074== by 0x4E8AC07: boost::regex_token_iterator<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::regex_token_iterator(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::basic_regex<char, boost::regex _traits<char, boost::cpp_regex_traits<char> > > const&, int, boost::regex_constants::_match_flags) (regex_token_iterator.hpp:200) ==25074== by 0x45D99C: application_ut_suite::test_logon::test_method() (application_ut.cpp:139) ==25074== Address 0x6a64588 is 0 bytes after a block of size 56 alloc'd ==25074== at 0x4C2506C: operator new(unsigned long) (in /usr/lib64/valgrind/amd64-linux/vgpreload_memcheck.so) ==25074== by 0x5811362: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator <char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::construct_init(boost::basic_regex<char, boost::regex_traits<char, boost::cpp_rege x_traits<char> > > const&, boost::regex_constants::_match_flags) (perl_matcher_common.hpp:73) ==25074== by 0x4E856D2: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator <char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::perl_matcher(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::_ _normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_i terator<char const*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, _ _gnu_cxx::__normal_iterator<char const*, std::string>) (perl_matcher.hpp:366) ==25074== by 0x4E8583A: bool boost::regex_search<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterat or<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char c onst*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, __gnu_cxx::__no rmal_iterator<char const*, std::string>) (regex_search.hpp:55) ==25074== by 0x4E85BEF: boost::regex_token_iterator_implementation<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex _traits<char> > >::init(__gnu_cxx::__normal_iterator<char const*, std::string>) (regex_token_iterator.hpp:109) ==25074== by 0x4E8AC07: boost::regex_token_iterator<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::regex_token_iterator(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::basic_regex<char, boost::regex _traits<char, boost::cpp_regex_traits<char> > > const&, int, boost::regex_constants::_match_flags) (regex_token_iterator.hpp:200) ==25074== by 0x442E4F: application_ut_suite::(anonymous namespace)::Test_Setup::Test_Setup(std::istream&, unsigned long) (application_ut.cpp:96) ==25074== by 0x45D99C: application_ut_suite::test_logon::test_method() (application_ut.cpp:139) ==25074== by 0x45F620: _ZN20application_ut_suiteL18test_logon_invokerEv (application_ut.cpp:133) ==25074== ==25074== Invalid write of size 8 ==25074== at 0x46CE8A: boost::detail::shared_count::shared_count() (shared_count.hpp:71) ==25074==:regex_traits<char, boost::cpp_regex_traits<char> > > const&, int, boost::regex_constants::_match_flags) (regex_token_iterator.hpp:200) ==25074== by 0x442E4F: application_ut_suite::(anonymous namespace)::Test_Setup::Test_Setup(std::istream&, unsigned long) (application_ut.cpp:96) ==25074== Address 0x6a64590 is 8 bytes after a block of size 56 alloc'd ==25074== at 0x4C2506C: operator new(unsigned long) (in /usr/lib64/valgrind/amd64-linux/vgpreload_memcheck.so) ==25074== by 0x5811362: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::construct_init(boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags) (perl_matcher_common.hpp:73) ==25074== by 0x4E856D2: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::perl_matcher(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::_cxx::__normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, __gnu_cxx::__normal_iterator<char const*, std::string>) (regex_search.hpp:55) ==25074== by 0x4E85BEF: boost::regex_token_iterator_implementation<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::init(__gnu_cxx::__normal_iterator<char const*, std::string>) (regex_token_iterator.hpp:109) ==25074== by 0x4E8AC07: boost::regex_token_iterator<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::regex_token_iterator(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, int, boost::regex_constants::_match_flags) (regex_token_iterator.hpp:200) ==25074== by 0x442E4F: application_ut_suite::(anonymous namespace)::Test_Setup::Test_Setup(std::istream&, unsigned long) (application_ut.cpp:96) ==25074== by 0x45D99C: application_ut_suite::test_logon::test_method() (application_ut.cpp:139) ==250ub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::construct_init(boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags) (perl_matcher_common.hpp:73) ==25074== by 0x4E856D2: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::perl_matcher(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, __gnu_cxx::__normal_iterator<char const*, std::string>) (perl_matcher.hpp:366) ==25074== by 0x4E8583A: bool boost::regex_search<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >&, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags, __gnu_cxx::__normal_iterator<char const*, std::string>) (regex_search.hpp:55) ==25074== by 0x4E85BEF: boost::regex_token_iterator_implementation<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::init(__gnu_cxx::__normal_iterator<char const*, snstants::_match_flags) (regex_token_iterator.hpp:200) ==25074== by 0x442E4F: application_ut_suite::(anonymous namespace)::Test_Setup::Test_Setup(std::istream&, unsigned long) (application_ut.cpp:96) ==25074== by 0x45D99C: application_ut_suite::test_logon::test_method() (application_ut.cpp:139) ==25074== by 0x45F620: _ZN20application_ut_suiteL18test_logon_invokerEv (application_ut.cpp:133) ==25074== Address 0x6a64598 is not stack'd, malloc'd or (recently) free'd **25074** new/new[] failed and should throw an exception, but Valgrind cannot throw exceptions and so is aborting instead. Sorry. ==25074== at 0x4C22E23: (within /usr/lib64/valgrind/amd64-linux/vgpreload_memcheck.so) ==25074== by 0x4C250C8: operator new(unsigned long) (in /usr/lib64/valgrind/amd64-linux/vgpreload_memcheck.so) ==25074== by 0x4E84680: __gnu_cxx::new_allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >::allocate(unsigned long, void const*) (new_allocator.h:92) ==25074== by 0x4E846AF: std::_Vector_base<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> >, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >::_M_allocate(unsigned long) (stl_vector.h:144) ==25074== by 0x4E8A4AE: std::vector<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> >, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*tor.tcc:395) ==25074== by 0x4E8A61E: std::vector<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> >, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >::insert(__gnu_cxx::__normal_iterator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> >*, std::vector<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> >, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > > >, unsigned long, boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > const&) (stl_vector.h:792) ==25074== by 0x4E8A73B: boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > > >::set_size(unsigned long, __gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>) (match_results.hpp:399) ==25074== by 0x4E8B1BF: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::find_imp() (perl_matcher_common.hpp:263) ==25074== by 0x5810D0A: boost::re_detail::perl_matcher<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::find() (perl_matcher_common.hpp:229) ==25074== by 0x4E85846: bool boost::regex_search<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost::sub_match<__gnu_cxx::__normal_iterator<char const*, std::string> > >, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::match_results<__gnu_cxx::__normal_iterator<char const*, std::string>, std::allocator<boost:::regex_traits<char, boost::cpp_regex_traits<char> > >::init(__gnu_cxx::__normal_iterator<char const*, std::string>) (regex_token_iterator.hpp:109) ==25074== by 0x4E8AC07: boost::regex_token_iterator<__gnu_cxx::__normal_iterator<char const*, std::string>, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >::regex_token_iterator(__gnu_cxx::__normal_iterator<char const*, std::string>, __gnu_cxx::__normal_iterator<char const*, std::string>, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, int, boost::regex_constants::_match_flags) (regex_token_iterator.hpp:200) ==25074== ==25074== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 3 from 1) ==25074== malloc/free: in use at exit: 64,694 bytes in 500 blocks. ==25074== malloc/free: 590 allocs, 89 frees, 103,110 bytes allocated. ==25074== For counts of detected errors, rerun with: -v ==25074== searching for pointers to 500 not-freed blocks. ==25074== checked 402,856 bytes. ==25074== ==25074== LEAK SUMMARY: ==25074== definitely lost: 0 bytes in 0 blocks. ==25074== possibly lost: 7,480 bytes in 190 blocks. ==25074== still reachable: 57,214 bytes in 310 blocks. ==25074== suppressed: 0 bytes in 0 blocks. ==25074== Rerun with --leak-check=full to see details of leaked memory.

2 2

[1.41.0] Release branch open for merges
by Beman Dawes 04 Sep '09

04 Sep '09

The release branch (https://svn.boost.org/svn/boost/branches/release) is open for merging all stable changes from trunk, including bug fixes and major upgrades to existing libraries. Breaking changes should be coordinated via the mailing list with the developers of the other libraries affected. New libraries may be added, but require permission of a release manager. In other words, except for new libraries, merging changes *does not* need permission from a release manager. I.e. just do it! The release schedule is more aggressive than usual on the front end so that we can maintain our quarterly release schedule: * September 13, 2009: branches/release closed for new libraries and breaking changes to existing libraries. Still open for bug fixes and other routine changes to all libraries. * September 20, 2009: Release managers start QA checks. * October 4, 2009: branches/release closed for major code changes. Still open for serious problem fixes and docs changes. * October 11, 2009: branches/release closed for all library changes except when specific permission given by release manager(s). * October 18, 2009: Beta release target date. Further betas and/or release candidates as feedback dictates. * November 1, 2009: Release ship date. Links relating to this release: * Google Calendar with the release schedule: <http://www.boost.org/development/index.html>. * Release schedule explanation: <http://svn.boost.org/trac/boost/wiki/ReleaseSchedule>. * Release practices for developers: <http://svn.boost.org/trac/boost/wiki/ImprovingPractices>. -- The release managers

3 3

Re: [boost] question about TMP
by DE 04 Sep '09

04 Sep '09

for those who is still interested i thought about types that a library user can actually use and finally came to this decision one can use something like //don't look at syntax, check out the concept matrix<double> m; //general rectangular dense matrix matrix<double, sparse> sp; //rectangular sparse matrix square<double> sq; //square matrix, although one might square<double, symmetric> sym; //use the following types which square<double, upper_triang> ut; //model corresponding concepts square<double, lower_triang> lt; //i.e. symmetric, upper- & lower //triangular matrices square<double, symmetric | sparse> sparse_sym; //also this square<double, lower_triang | sparse> sparse_lt;//might be useful band<double> b; //guess... band<double, symmetric> bs; //why not? //etc... all these types provide strict explicit interfaces e.g. - 'square' provides 'resize(size_t)' member but not 'resize(size_t, size_t)' - 'band' provides useful 'bandwidth()' member and 'diagonal(int)' member which returns diagonal (might be useful for implementing a band solver) -- Pavel

1 0

optional<optional<T>>
by Andrei Alexandrescu 04 Sep '09

04 Sep '09

Hello, I'm defining an "optional" type for D's standard library modeled similarly to Boost.optional. An interesting question came up - should optional<optional<T>> fold itself into optional<T>, or is "double optional" an interesting concept of its own? I thought I'd ask here because by now there's a significant body of experience with optional<T>. I perused the online documentation and the forum and couldn't find information about that specific detail. Thanks, Andrei

14 22

Re: [boost] [ublas] Extending type_traits for use with Boost Units
by Matthias Schabel 04 Sep '09

04 Sep '09

> Am Wednesday 26 August 2009 schrieb Manoj Rajagopalan: >> Hi UBLAS developers, >> >> I have begun using Boost Units which was introduced in boost v >> 1.36. I am working on extending UBLAS to support physically >> dimensioned types and I have provided a short example below. >> >> This can be achieved efficiently if a few extensions to UBLAS >> type_traits are allowed and I was wondering if anyone would object to >> this. An example of such an extension would be the introduction of >> "sqrt_type" as the type for the square root operation. This would be >> the return type for type_traits<T>::type_sqrt(). For arithmetic types >> like float and double the template can be partially specialized so >> that sqrt_type is float or double but for physically dimensioned >> types like quantity<length,double>, sqrt_type can be set to >> quantity<length^(1/2), double>. > > This is a good idea. Could you prepare a patch and a small example > program? > >> I have already adapted most of vector_expression.hpp for use with >> these dimensioned quantities with work-arounds for these extensions >> but this is getting ugly and unwieldy. > > is it possible to deduct the square_type from operator*()? E.g., using > return type deduction (see detail/returntype_deduction and > promote_traits from traits.hpp) You might also want to get in touch with Steven Watanabe. I believe he has done some work toward making UBLAS and Boost.Units interoperable. Matthias

2 1

Re: [boost] [Polygon] What does this error mean?
by Phil Endecott 03 Sep '09

03 Sep '09

Dear Luke (& others), Here's some test code, followed by the errors that I get when I try to compile it. It boils down to some confusion about whether set is a type or a function. Am I doing something that isn't allowed? Thanks for any suggestions. #include <boost/polygon/polygon.hpp> template<typename COORD_T> struct Box { typedef COORD_T coord_t; coord_t x0; coord_t y0; coord_t x1; coord_t y1; }; typedef int screen_coord_t; typedef Box<screen_coord_t> screen_box_t; namespace boost { namespace polygon { template <> struct geometry_concept<screen_box_t> { typedef rectangle_concept type; }; template <> struct rectangle_traits<screen_box_t> { typedef screen_coord_t coordinate_type; typedef std::pair<screen_coord_t,screen_coord_t> interval_type; static inline interval_type get(const screen_box_t& rectangle, orientation_2d orient) { return (orient==HORIZONTAL) ? std::make_pair(rectangle.x0,rectangle.x1) : std::make_pair(rectangle.y0,rectangle.y1); } }; }; }; typedef boost::polygon::polygon_90_set_data<screen_coord_t> markers_t; markers_t markers; void draw_marker(screen_box_t sb) { using namespace boost::polygon::operators; markers |= sb; } /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_set.h: In function ‘typename boost::enable_if<typename boost::polygon::gtl_and_3<boost::polygon::y_r_assign, typename boost::polygon::is_mutable_rectangle_concept<typename boost::polygon::geometry_concept<T>::type>::type, typename boost::polygon::is_rectangle_concept<typename boost::polygon::geometry_concept<T2>::type>::type>::type, rectangle_type_1>::type& boost::polygon::assign(rectangle_type_1&, const rectangle_type_2&) [with rectangle_type_1 = boost::polygon::rectangle_data<int>, rectangle_type_2 = Box<int>]’: /usr/local/src/gtl/boost/polygon/detail/iterator_geometry_to_set.hpp:34: instantiated from ‘boost::polygon::iterator_geometry_to_set<boost::polygon::rectangle_concept, rectangle_type>::iterator_geometry_to_set(const rectangle_type&, boost::polygon::direction_1d, boost::polygon::orientation_2d, bool) [with rectangle_type = Box<int>]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:137: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(const geometry_type&, bool, boost::polygon::orientation_2d) [with geometry_type = Box<int>, T = int]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:113: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(iT, iT, boost::polygon::orientation_2d) [with iT = const Box<int>*, T = int]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:318: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_pe, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator+=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = Box<int>]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:329: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_be, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator|=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = screen_box_t]’ testpoly.cc:41: instantiated from here /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_set.h:71: error: ‘template<class _Key, class _Compare, class _Alloc> class std::set’ is not a function, /usr/local/src/gtl/boost/polygon/point_concept.hpp:77: error: conflict with ‘template<class T, class coordinate_type> void boost::polygon::set(T&, boost::polygon::orientation_2d, coordinate_type, typename boost::enable_if<typename boost::polygon::is_mutable_point_concept<typename boost::polygon::geometry_concept<T>::type>::type, void>::type*)’ /usr/local/src/gtl/boost/polygon/rectangle_concept.hpp:192: error: in call to ‘set’ /usr/local/src/gtl/boost/polygon/detail/iterator_geometry_to_set.hpp:34: instantiated from ‘boost::polygon::iterator_geometry_to_set<boost::polygon::rectangle_concept, rectangle_type>::iterator_geometry_to_set(const rectangle_type&, boost::polygon::direction_1d, boost::polygon::orientation_2d, bool) [with rectangle_type = Box<int>]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:137: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(const geometry_type&, bool, boost::polygon::orientation_2d) [with geometry_type = Box<int>, T = int]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:113: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(iT, iT, boost::polygon::orientation_2d) [with iT = const Box<int>*, T = int]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:318: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_pe, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator+=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = Box<int>]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:329: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_be, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator|=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = screen_box_t]’ testpoly.cc:41: instantiated from here /usr/local/src/gtl/boost/polygon/rectangle_concept.hpp:192: error: no matching function for call to ‘set(boost::polygon::rectangle_data<int>&, boost::polygon::orientation_2d_enum, std::pair<int, int>)’ /usr/local/src/gtl/boost/polygon/detail/iterator_geometry_to_set.hpp:34: instantiated from ‘boost::polygon::iterator_geometry_to_set<boost::polygon::rectangle_concept, rectangle_type>::iterator_geometry_to_set(const rectangle_type&, boost::polygon::direction_1d, boost::polygon::orientation_2d, bool) [with rectangle_type = Box<int>]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:137: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(const geometry_type&, bool, boost::polygon::orientation_2d) [with geometry_type = Box<int>, T = int]’ /usr/local/src/gtl/boost/polygon/polygon_90_set_data.hpp:113: instantiated from ‘void boost::polygon::polygon_90_set_data<T>::insert(iT, iT, boost::polygon::orientation_2d) [with iT = const Box<int>*, T = int]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:318: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_pe, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator+=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = Box<int>]’ /usr/local/src/gtl/boost/polygon/detail/polygon_90_set_view.hpp:329: instantiated from ‘typename boost::enable_if<typename boost::polygon::gtl_and<boost::polygon::operators::y_ps90_be, typename boost::polygon::is_polygon_90_set_type<polygon_set_type_2>::type>::type, boost::polygon::polygon_90_set_data<coordinate_type> >::type& boost::polygon::operators::operator|=(boost::polygon::polygon_90_set_data<coordinate_type>&, const geometry_type_2&) [with coordinate_type_1 = int, geometry_type_2 = screen_box_t]’ testpoly.cc:41: instantiated from here /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_set.h:71: error: ‘template<class _Key, class _Compare, class _Alloc> class std::set’ is not a function, /usr/local/src/gtl/boost/polygon/point_concept.hpp:77: error: conflict with ‘template<class T, class coordinate_type> void boost::polygon::set(T&, boost::polygon::orientation_2d, coordinate_type, typename boost::enable_if<typename boost::polygon::is_mutable_point_concept<typename boost::polygon::geometry_concept<T>::type>::type, void>::type*)’ /usr/local/src/gtl/boost/polygon/rectangle_concept.hpp:193: error: in call to ‘set’ /usr/local/src/gtl/boost/polygon/rectangle_concept.hpp:193: error: no matching function for call to ‘set(boost::polygon::rectangle_data<int>&, boost::polygon::orientation_2d_enum, std::pair<int, int>)’

6 12

[1.41.0] New libraries?
by Beman Dawes 03 Sep '09

03 Sep '09

Are there any new libraries that will be ready for 1.41.0? There is a New Library Checklist that needs to be gone over with the release managers before merging new libraries into branches/release. See http://svn.boost.org/trac/boost/wiki/ReleasePractices/ManagerCheckList#NewL… Thanks, --Beman

2 1

[graph] quickbook reference docs and formatting
by Andrew Sutton 03 Sep '09

03 Sep '09

Jeremiah, Nick, others with opinions.... Two questions: First, I need a second opinion on some formatting alternatives for the quickbook docs w.r.t the documentation of member/non-member functions of the graph classes. These should be mostly buildable - there are some errors about missing links, but they aren't fatal. Let me know if there are issues building them. I got the doc toolchain working a while ago and I'm afraid to mess with it. I may not have the same set up as everybody else. Hopefully I do. The HTML docs give a flat listing with each function separated by a HR element, which is effective (although not especially navigable). Other lib**raries (e.g., Boost.Filesystem) present a similar listing although without the HR's to divide the content. I've tried putting these in a table to improve readability, and it works a little but, but I don't have enough control over the table to prevent auto-wrapping, which can break a function declaration line in weird places. So what's better: a flat listing or a table? Is there a third option? Generating reference docs via Doxygen (like ProgramOptions) probably isn't a viable solution since there's a lot of metaprogramming and atypical class construction going on in the BGL. Second, all of the reference docs for graph classes cite their associated types via the graph_traits and property_map templates. For most of these types, this strikes me as superfluous at best and slightly disingenuous at worst. Traits classes are only required in a generic context, not when working with a concrete type. If your graph class defines a nested type, vertex_iterator, why not use it directly? I feel that the reference documentation for data structures would be better served by focusing on the specifics of the data structure, not its generic interfaces. That's what the concepts are for. Thoughts? Andrew Sutton andrew.n.sutton(a)gmail.com

2 1

[date_time, Boost 1.40.0]
by Christoph 03 Sep '09

03 Sep '09

including boost/date_time/posix_time/posix_time.hpp or boost/date_time/gregorian/gregorian.hpp gives lots of warning for the following line(s): (boost/date_time/gregorian/conversion.hpp; posix_time, tooo) line 44 std::tm datetm = {}; // zero initialization is needed for extension members, like tm_zone I admit I don't understand the comment. Is it possible to fix that (correctly) such that including the header does not produce like 20 warnings in each .cpp file including the header? (I am using linux running gcc 4.1.2) Best regards Christoph

4 5

[serialization] using boost::serialization::collection_size_type and backwards compatibility
by joaquin＠tid.es 03 Sep '09

03 Sep '09

An observant colleague has noticed that Boost.MultiIndex serialization uses std::size_type instead of the adviced boost::serialization::collection_size_type: https://svn.boost.org/trac/boost/ticket/3365 My question is: if I just change std::size_type with boost::serialization::collection_size_type in Boost.MultiIndex serialization code, will backwards compatibility be preserved, i.e. will users be able to load archives saved with the old std::size_type variant? If not, what's the suggested way to handle this issue? Thank you, Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

3 3

compile-time for-loop
by klaus triendl 03 Sep '09

03 Sep '09

I wonder whether a compile-time for-loop is useful enough so that it would get included in the mpl library; it's very similar to what fold does but it can be used for computations with types other than sequence containers. The loop construct takes a start value, a loop condition and a function calculating the next start value for the next loop recursion and additionally a state together with a binary operation serving as loop body: namespace boost { namespace mpl { template< typename Start, typename UnaryLoopTest, typename BinaryNext , typename State, typename BinaryOp > struct for_: eval_if< // loop as long as the loop condition yields true typename apply< UnaryLoopTest, typename Start::type >::type, // next loop iteration: recursive call for_< // calculate next loop value typename apply< BinaryNext, State, typename Start::type >::type, // pass on UnaryLoopTest and pass on BinaryNext UnaryLoopTest, BinaryNext, // calculate next state typename apply< BinaryOp, State, typename Start::type >::type, // pass on BinaryOp BinaryOp >, // loop termination if loop condition yields false State > {}; } } // That's an example how to use the for-loop: using namespace boost; template<typename T, T N> struct cross_total: mpl::for_< // start mpl::integral_c<T, N>, // loop condition mpl::not_equal_to<mpl::_1, mpl::integral_c<T, 0> >, // calculate next value mpl::divides<mpl::_2, mpl::int_<10> >, // state = current cross sum of already iterated digits mpl::int_<0>, // binary function is loop body: crosstotal += digit mpl::plus< mpl::_1, mpl::modulus<mpl::_2, mpl::int_<10> > > >::type {}; </code> More useful may be to calculate a number's digits for any base, which can be used to calculate the required maximum storage size for a type (I know that there's std::numeric_limits<> but this one would be more general). Klaus Triendl

4 6

[Polygon] performance
by Simonson, Lucanus J 03 Sep '09

03 Sep '09

Performance has become a critical aspect of this review with the revelation that Barend claims significant performance advantage with his recent implementation. I would like to address this issue directly and, unfortunately, I must do so by addressing Barend's implementation and comparing it to my own, which I would have preferred to avoid. I realize that this comparison of the two algorithms may appear confrontational. My intention is to focus on technical issues to allow people to understand Barend's performance claims in the context of what the two algorithms have in common and how they differ. My understanding of Barend's algorithm is based solely on what he has told me, and he refused to tell me enough to allow me to implement it myself, so if I am in error in my description of it I trust he will promptly correct me. First, I do not believe that Barend's implementation is numerically robust when instantiated with float or double. Successfully passing tests is not proof that his algorithm will not generate self intersecting polygons at its output. Specifically, it is my understanding that his algorithm snaps intersection points to the floating point grid at the end of computation when he writes out output polygons. This means that edges may move laterally a distance dependent on the exponent of the floating point value of the result. In floating point coordinates a vertex may lie arbitrarily close to a nearby edge. Even a very small lateral movement of that edge due to loss of precision in the floating point representation has the potential to cross a nearby vertex and interduce self intersection in the output polygons. Since "simple polygons" is a common precondition to many algorithms (including Barend's own) it is simply unacceptable for there to be any chance of this post condition not being satisfied. Note that infinite precision floating point calculations don't solve this problem if you convert the output to regular floating point at some later stage, which is the common way the algorithm's output would be consumed. Second, Barend has stated that his algorithm does the same thing as mine. This is simply not true. Barend's algorithm imposes quite a few preconditions on its inputs (non-self intersecting being just one example) while mine imposes none. The two arguments of a boolean operation in my library may be any number of intersecting and overlapping polygons, Barend requires that all polygons be simple and non-overlapping. My algorithm accepts a broader range of inputs, which makes it more general and more powerful than Barend's algorithm and a better algorithm to use in a generic interface where preconditions become concept requirements for input geometry data. Furthermore, my algorithm has more output modes such as trapezoidization and keyholing as well as the flexibility to perform n-layer operations such as connectivity extraction and map overlay. Barend's algorithm does not. Comparing Barend's intersection algorithm to my own is not an apples to apples comparision, it is an apple to fruit basket which happens to contain an apple comparision. For these two reasons I think we should take Barend's performance claims with a grain of salt. When compared to other libraries that are known to be numerically robust (GPC, CGAL, Geos) my library is sometimes slower, sometimes faster in Barend's own benchmarking. Only Barend's algorithm is always faster in his benchmarking. However, if Barend's library has the potential to produce self intersecting output it is not even in the same class as these others. My benchmark data can be reproduced using the forcgal.cpp file in the sandbox/gtl directory. I provided it when Andreas asked. I admit that my algorithm could be faster. For the benchmarks I performed I estimated it could be up to 10X faster. For Barend's benchmarks with many pointed star polygons which result in O(n^2) pathological performance of my admittedly suboptimal line segment intersection algorithm that number might be higher sill. I would prefer that the focus of the review be the concept interfaces (function declarations) and how the typesystem is implemented so that we can decide whether it is a good model for a generic geometry API. Changes to eg. the line intersection algorithm or internals of polygon_set_data class can be made without breaking code that depends on the library API. If someone implements a true drop in replacement for my polygon intersection algorithm (or just for line segment intersection) and licenses it under the boost license we can drop it in if it is faster and all any user should notice is that the library is faster in a new release of boost. I don't think there are any decisions I made in the design or implementation of the concept type system or library interfaces that prevent or even make difficult such a change to its implementation details. Overall, I don't think we should view this review as an either or Boost.Polygon now or GGL later decision. There is no reason both libraries cannot be accepted in due time. Barend has made quite a bit a progress since boostcon and I am genuinely happy for him for what he has achieved. Thanks, Luke

3 2

Formal Review of Boost.Polygon extended one more week: until September 9, 2009
by Fernando Cacciola 02 Sep '09

02 Sep '09

Dear developers, The review of Boost.Polygon was initially scheduled to end today. However, the discussions are in their best moment only now so the review period was extended by one week, until September 9, 2009 (that is next Wednesday). Best Fernando Cacciola Review Manager

1 0

[pool] patch to make pool support zero sized allocations.
by Steven Watanabe 02 Sep '09

02 Sep '09

AMDG The patch at https://svn.boost.org/trac/boost/attachment/ticket/386/pool.patch allows the pool classes to support zero sized allocation, by returning a null pointer. std::vector sometimes allocates a zero sized block, so this is necessary for pool_allocator. Returning a null pointer is the simplest solution and I'm that the standard allows an allocator to return the null pointer when asked for a block of zero elements. Okay to commit? In Christ, Steven Watanabe

1 1

Re: [boost] [mpl, units] rational and static_rational
by Matthias Schabel 02 Sep '09

02 Sep '09

> I am looking for a template library that can handle compile time > rationals, ideally with a similar interface to mpl::int_ and that > plays well with boost::rational (the dynamic type). > > First I found boost/mpl/math/rational_c.hpp but soon I realized that > it doesn't work with basic operations like mpl::plus, it doesn't even > simplify reducible fractions (i.e. 2/4 -> 1/2), in fact it looks like > it is just the storage of two (static) integers. Is this something > that will be developed in the future or am I using it in the wrong > way? > > Then I found boost::units::static_rational which is more promising, > because it simplifies fractions and works with mpl::plus, but it is > not integrated with boost::rational nor has an interface similar to > that of mpl metatypes. > > Is there a way of extending mpl::math::rational_c with the existing > libraries in boost, or a simple way to make > boost::units::static_rational have an interface similar to mpl and > also have a value type that returns it runtime boost::rational value? I certainly would have no objection to repackaging the static_rational type used in Boost.Units as an MPL type that plays nicely with Boost.Rational. My advice would be to put together a functional implementation and propose it for a mini-review. We could easily typedef units::static_rational -> mpl::rational_ in the units library. Matthias

1 0

[polygon] Overload resolution for operators fails
by Joachim Faulhaber 02 Sep '09

02 Sep '09

Hi Luke and polygonists, trying to set up some law based tests for boost::polygon I faced difficulties with the overload resolution of operators under msvc-9. This is the code sniplet where the problems occur: ----------------------------------------------------------- #include <boost/validate/laws/law.hpp> #include <boost/polygon/polygon.hpp> // Here I map a PolygonSet class to geometry_concepts according to // the docs: #include <boost/itl_xt/custom_polygon.hpp> namespace boost{namespace itl { template <typename Type> class PolygonCommutativity : public Law<PolygonCommutativity<Type>, LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)> { // a o b == b o a . . . bool holds() { using namespace boost::polygon; using namespace boost::polygon::operators; Type value_a = this->template getInputValue<operand_a>(); Type value_b = this->template getInputValue<operand_b>(); Type left = value_a; left += value_b; // Compiler fails to find the appropriate overload // but // this works self_assignment_boolean_op<Type,Type,0>(left, value_b); // and also this works boost::polygon::operators::operator+=<Type,Type>(left, value_b); // and this boost::polygon::operators::operator+=(left, value_b); . . . return equivalence(left, right); } }; ----------------------------------------------------------- moreover, if my custom PolygonSet conainer implements an operator += this operator is *silently* chosen by the compiler, so the wrong addition function is called! Contrary to the traditional understanding of a concept, that defines *requirements* for a parameter class it can use, we have to take care here, that the client class *does not* implement certain operations. I am afraid this is not a good thing. I hope this is fixable, may be the error is on my side but I can't see it yet. Regards Joachim

2 2

[property_tree] Still no support for space
by Preston A. Elder 02 Sep '09

02 Sep '09

I noticed property_tree just got updated in the SVN repository. As per my previous email, RapidXML was upgraded from 1.0 -> 1.13. All well and good. This did fix problems with whitespace handling in previous versions - or more correctly, it split the functionality so it was controlled by 2 different flags. However, in addition to this, the flags passed to RapidXML have changed. Specifically, now the flags parse_normalize_whitespace and parse_trim_whitespace are both passed to RapidXML. And there is no way to disable this. In fact, there is no way to adjust space parsing at all in property_tree. The reason this is of concern to me is this. There is no way to get this to work: <field> <field> or <field>] <field> or <field> </field> None of which will output the space in the result. RapidXML doesn't parse an XSL file, nor does it understand xml:space. So even the following will not work: <field xml:space="preserve"> </field> or <field xml:space="preserve">] </field> In short, could you PLEASE adjust the RapidXML (which is still the default XML parser) options not to mangle the living heck out of all spaces, or provide the ability for the user to specify the behavior they want (like you do with comments). I should also mention that RapidXML defaults both parse_normalize_whitespace and parse_trim_whitespace to off. I did my own testing, adjusting the flags to RapidXML. If I leave parse_normalize_whitespace ON, but turning off parse_trim_whitespace, the <field> </field> and <field>] </field> examples above work. No adjustment either of these settings will make <field> </field> work. PreZ

2 1

boost::regex Library crashes in MSVC8.0
by Naren Ramakrishnan 02 Sep '09

02 Sep '09

Hi, I am Boost novice and am trying to build a sample application from boost examples. The following is the environment details OS: Winxp sp2. Boost version : 1.40.0 Compiler / IDE : MSVC8.0/ Visual Studio 2005 I built the boost libraries using the above compiler using the bjam.exe tool and installed boost using the same tool(bjam.exe install). When I run the program(given below) by linking against libboost_regex-vc80-mt-1_39.lib with the following define flags(/D BOOST_REGEX_MATCH_EXTRA /D BOOST_REGEX_NO_LIB), I get a crash with the following message Unhandled exception at 0x00401e73 in BOOST TEST.exe: 0xC0000005: Access violation reading location 0x6c707849. Stack Trace is > BOOST TEST.exe!std::vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >::~vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >() Line 1088 C++ BOOST TEST.exe!std::vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >::_Destroy(boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > * _First=0x00383888, boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > * _Last=0x78138cd9) Line 1083 + 0x1d bytes C++ BOOST TEST.exe!std::vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >::~vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >() Line 1096 C++ BOOST TEST.exe!std::vector<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >::_Destroy(boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > * _First=0x00387c80, boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > * _Last=0x00387cbc) Line 1083 + 0x1d bytes C++ BOOST TEST.exe!boost::match_results<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >::~match_results<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> >,std::allocator<boost::sub_match<std::_String_const_iterator<char,std::char_traits<char>,std::allocator<char> > > > >() Line 81 + 0x83 bytes C++ BOOST TEST.exe!print_captures(const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & regx={...}, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & text={...}) Line 44 + 0x22 bytes C++ BOOST TEST.exe!main(int __formal=, int __formal=) Line 48 + 0x3c bytes C++ BOOST TEST.exe!__tmainCRTStartup() Line 586 + 0x17 bytes C The program is #include "stdafx.h" #include <boost/regex.hpp> #include <iostream> using namespace boost; void print_captures(const std::string& regx, const std::string& text) { boost::regex e(regx); smatch what,w; std::cout << "Expression: \"" << regx.c_str() << "\"\n"; std::cout << "Text: \"" << text.c_str() << "\"\n"; if(boost::regex_search(text, what, e, boost::match_perl)) { unsigned i, j; std::cout << "** Match found **\n Sub-Expressions:\n"; for(i = 0; i < what.size(); ++i) std::cout << " $" << i << " = \"" << what[i].str().c_str() << "\"\n"; std::cout << " Captures:\n"; for(i = 0; i < what.size(); ++i) { std::cout << " $" << i << " = {"; j=0; for(j = 0; j < what.captures(i).size(); ++j) { if(j) std::cout << ", "; else std::cout << " "; std::cout << "\"" << what.captures(i)[j].str().c_str() << "\""; } std::cout << " }\n"; } } else { std::cout << "** No Match found **\n"; } } int main(int , char* []) { print_captures("Microsoft ", " Microsoft Internet Explorer"); print_captures("(.*)bar|(.*)bah", "abcbar"); print_captures("(.*)bar|(.*)bah", "abcbah"); print_captures("^(?:(\\w+)|(?>\\W+))*$", "now is the time for all good men to come to the aid of the party"); return 0; } However when I compile and run this program against boost libraries available in sourceforge under boost-binaries, it works fine. I am sure I am missing something. Could you please help me out Thanks Naren

3 4

Boost.FileSystem talk from BoostCon now available
by Marshall Clow 01 Sep '09

01 Sep '09

at <http://blip.tv/file/2541291> More to come as I dig myself out..... -- Marshall

1 0

[serialization] working around the pointer_conflict exception?
by T. Farago 01 Sep '09

01 Sep '09

I have implemented the serialise library of BOOST to my own classes. Using a single entry point it recursively goes through every member and saves the values. Of course initial implementation yielded the pointer_conflict expression as for example while going through objects A,B,C object A may have a pointer to B, and only afterwards is B actually saved. I tried - and thought - to fix this by using a two-phased approach. First I save all the actual objects from the entry point, secondly only the pointers. eg save_objects = true; ar & my_object; save_objects = false; ar & my_objects; and inside every class: class A { public: int a; int *b; serialise() { if (save_objects) { ar & a; } else { ar & b; } } }; This seemed sound but only during debugging did I realise that the second run of the serialiser doesn't do anything since my_object is already saved. So this won't work. Does anyone have better ideas on solving this problem, or has encountered and already solved this issue? -- Using Opera's revolutionary e-mail client: http://www.opera.com/mail/

2 2

Boost Polygon library Review
by Kai Benndorf 01 Sep '09

01 Sep '09

Dear developers, we are currently evaluating the boost polygon library as a possible replacement for our currently used package for polygon boolean operations. Because the review process is soon at an end i want to inform you of our experiences so far. For short, i vote for inclusion of the polygon lib into boost. We are evaluating it in the scope of an analysis tool out of the EDA field. One task in this tool is to determine overlays of copper planes on a pcb. For this we need the plane intersection functionality. We have integrated the boost polygon lib currently to use it in parallel to our old library. Up to now we have found no errors in the calculated plane intersections, and there are some quite complicated planes, with complicate holes on the test pcb. This is very promising and the results seem to be reliable. We used the library on Windows XP, MSVC 2008, only. No compilation problems occured. Double vs. integer coordinates. Our planes are described with double coordinates in mm. We convert them for the boost polygon lib to integer by multiplying them with a constant factor. A first try with an factor of 1e5 leaded to an error (overflow?). With a factor of 1e4 this error vanished. Our first approach was to use the polygon and polygon with hole classes provided by the library and copy our coordinates into them. It works, but the creation of the objects with the set( itBegin, itEnd) functions was really slow, especially for copying the holes into the polygon. Our current approach is with some own intermediate polygon and polygon with holes classes, which allocates the necessary memory on creation. This is a lot faster and is really usable. A third and still better approach would be to use the same polygon classes as in the rest of our application, but i postponed this for now. The performance seems to be slower than our old library, but this is not really evaluated yet, there can e.g. still be conversion penalties. The documentation was sufficient enough to integrate the library in our application, but surely can be better. Because i'm not experienced in such an extensive template usage as it is done in the polygon lib, i omit comments about the design of the library. But at least it proved, that it can really be used to work reliable on external polygon objects. Best regards Kai Benndorf

2 1

windows timeout implementation
by Gennadiy Rozental 01 Sep '09

01 Sep '09

Hi, I have windows timeout support implemented for boost::execution monitor. It requires multithreading and thus introduces additional dependencies. I am thinking of making it available with compile time flag. Any comments/suggestions are welcome. Gennadiy

4 4

[GSoC] Boost.Python py3k support project final report
by Haoyu Bai 01 Sep '09

01 Sep '09

Hi, As GSoC is officially finished, this is the final report of the Boost.Python py3k(Python 3) support project. The goal of this project is to provide seamless support for Python 2 and 3 in Boost.Python. So extension modules using Boost.Python can be easily migrated to Python 3. The SVN branch is located at: https://svn.boost.org/svn/boost/sandbox-branches/bhy/py3k/ Status ===== Currently, all the BPL test cases passed when running under Python 3, and there are almost no change for most of the test cases. To support the Python 3 unicode string, some of the default converts between PyString and C/C++ strings are changed to convert between PyUnicode and C/C++ strings. Support for py3k in Boost.Build is done. Also, a piece of document is written in the "News" part of BPL document. API Changes ========== There are some minor API changes: 1) Introduced object.contains where x.contains(y) is equivalent to Python code y in x. Now dict.has_key is just a wrapper of object.contains. 2) When building against Python 3, str.decode will be removed. 3) When building against Python 3, the original signature of list.sort, which is: void sort(object_cref cmpfunc); will change to: void sort(args_proxy const &args, kwds_proxy const &kwds); This is because in Python 3 list.sort requires all its arguments be keyword argument. So you should call it like this: x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true)))); // This is equivalent to the Python call x.sort(reverse=true) 4) When building Boost.Python against Python older than 2.6, the following macros will be defined in Boost.Python header: # define Py_TYPE(o) (((PyObject*)(o))->ob_type) # define Py_REFCNT(o) (((PyObject*)(o))->ob_refcnt) # define Py_SIZE(o) (((PyVarObject*)(o))->ob_size) These are macros defined in Python >=2.6 header. We defined for Python < 2.6 so when you are using Boost.Python, these macros will be always available. Please refer to PEP 3123 (http://www.python.org/dev/peps/pep-3123/) for details about these macro. Building and Testing =============== To build Boost.Python with Python 3, first write your user-config.jam contains these line: using python : 2.6 ; using python : 3.2 ; where the "2.6" and "3.2" should be replaced by the actual version of Python 2 and Python 3 on your system, respectively. Then call "bjam", it will build out a "libboost_python.so" and a "libboost_python3.so". The latter one is the Boost.Python library built against Python 3. To run test cases against Python 3, what you need to do is to switch into the libs/python/test, then run: bjam python=3.2 It will automatically call the "2to3" tool to convert the Python source code in test case to Python 3 syntax. So we only need to maintain the test cases in Python 2. Further Works =========== I'm going to merge the py3k branch back to trunk. After the merge, more tests can be done to check is there any regression, also some people may want to start to use it to make your projects run on Python 3. Then I can get some bug report and feedback, thus more improvement is expected. Thanks! -- Haoyu BAI School of Computing, National University of Singapore.

2 1