September 2009 - Boost - lists.preview.boost.org

[Graph] 1.40 Static Link Issue
by Gordon Smith 07 Sep '09

07 Sep '09

There seems to be an unused bool in fruchterman_reingold.hpp: bool vertex_migration = false; Which will cause link errors if included in more than one statically linked library. Gordon.

1 0

[mpi] non-char strings
by Isidor Zeuner 07 Sep '09

07 Sep '09

The last two checkouts I installed both failed passing strings through boost::mpi communication methods when the element type was not char. So maybe someone besides me will have use for the attached patch which makes it work again. I assume this way of passing strings isn't here to stay anyway since boost::serialization also handles strings. Best regards, Isidor

3 5

Release branch test results with MPI dropped on floor
by Steve M. Robbins 06 Sep '09

06 Sep '09

Hi, Now that 1.40 is out, can we get the release branch testing result scripts fixed so that they understand MPI runs? c.f. http://lists.boost.org/Archives/boost/2009/08/155466.php http://lists.boost.org/boost-testing/2009/08/6353.php Thanks, -Steve

4 4

[hs] Quickbook highlighting doesn't work in KDE 4.3
by Andrey Semashev 06 Sep '09

06 Sep '09

I'm not sure it's the right place for this, so sorry if it's off-topic. I'm trying to use Boost.HS* with Kate from KDE 4.3 on Ubuntu 9.04 but it doesn't work. There appears no "boost::hs" group in the Toost->Highlighting menu, neither does it color the quickbook files. Have anyone run into such kind of problems? PS: I successfully used Boost.HS with previous KDE versions (4.1 for sure, not sure about 4.2). This tool really helps to document the library, many thanks to the author. * http://www.drivehq.com/web/matias.capeletto/boost_hs/doc/html/index.html

2 2

Failures for GCC 4.4.1 with gnu++0x
by Beman Dawes 06 Sep '09

06 Sep '09

9 19

[Boost.Function] How about parallel functions?
by Kasra 06 Sep '09

06 Sep '09

Hi, I required to call few functions is separate threads and use the results. However, the code for this looks really ugly, you have to create threads, then join the threads when ever you require the result of the functions. So I have created a boost.parallel_function library that does this seamlessly just like invoking a normal function and it only joins the thread when the value of the function result type is required. Is this library of any interest to any one? Here is the a hello world example: #include <cstdlib> #include <limits> #include <boost/parallel_function.hpp> using namespace boost; int F0() { volatile int x = 0; for(int i=0; i<std::numeric_limits<int>::max()/1024; i++) x ^= std::rand(); return (int)x; } int F2(int y) { volatile int x = 0; for(int i=0; i<std::numeric_limits<int>::max()/512; i++) x ^= std::rand(); return (int)x ^ y; } int main() { typedef boost::parallel_function< void ( ) > f0_type; typedef boost::parallel_function< void (int) > f1_type; f0_type f0( &::F0 ); f1_type f1( &::F1 ); f0_type::result_type r0 = f0(); f1_type::result_type r1 = f1(32); // use r0 and r1 as if they are int r0 += 34; int value = r1 *= r0 + 452; std::cout << "Hello world " << value << std::endl; return 0; } With Best Regards Mr. Kasra Nassiri Department of Mathematics & Computer Science Imperial College London

3 2

Bug in date_time::subsecond_duration
by Jon Spencer 06 Sep '09

06 Sep '09

There is a needless loss of range in the constructor of date_time::subsecond_duration. The argument is multiplied by the resolution of the base_duration, which could potentially overflow, and then divided by frac_of_second. The patch below reduces the amount of overflow and is identical if one resolution is an integer multiple of the other. The same technique is used elsewhere in the file. Also see this posting on the subject (http://lists.boost.org/boost-users/2008/10/41763.php) --- boost/date_time/time_duration.hpp +++ boost/date_time/time_duration.hpp @@ -267,7 +267,7 @@ public: typedef typename base_duration::traits_type traits_type; explicit subsecond_duration(boost::int64_t ss) : - base_duration(0,0,0,ss*traits_type::res_adjust()/frac_of_second) + base_duration(0,0,0,traits_type::res_adjust()<frac_of_second?ss/(frac_of_second/traits_type::res_adjust()):ss*(traits_type::res_adjust()/frac_of_second)) {} };

1 0

Weak pointer to object not managed by a shared_ptr
by Mateusz Loskot 05 Sep '09

05 Sep '09

Hi, One of the smart pointer techniques [1] explains use of weak_ptr pointer to object not managed by a shared_ptr. [1] http://www.boost.org/doc/libs/1_40_0/libs/smart_ptr/sp_techniques.html I'm wondering what would be practical use case of that? Is it a part of any of known idioms or patterns? Also, is it valid to assume that this technique can extend lifetime of X so of the internal integral X::i_ ? Here is a simple test case based on the technique explained in the smartptr docs [1] with my questions marked using XXX tag: /// begin of program /////////////////////////////////////////////// #include <exception> #include <iostream> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> using namespace std; using namespace boost; struct null_deleter { void operator()(void const *) const { std::cout << "deleter\n"; } }; class X { public: explicit X(int i): this_(this, null_deleter()), i_(i) {} X(X const & rhs): this_(this, null_deleter()), i_(rhs.i_) {} X & operator=(X const & rhs) { i_ = rhs.i_; return *this; } weak_ptr<X> get_weak_ptr() const { return this_; } int get_i() const { return i_; } private: shared_ptr<X> this_; int i_; }; int main() { try { shared_ptr<X> spx; { X x1(7); // XXX: lifetime is extended here? spx = shared_ptr<X>(x1.get_weak_ptr()); } // XXX: No exception. x1 is still alive, so the pointer valid? cout << spx->get_i() << std::endl; } catch (bad_weak_ptr const& e) { cerr << e.what() << endl; } catch (exception const& e) { cerr << e.what() << endl; } catch (...) { cerr << "unknown error\n"; } return 0; } /// end of program /////////////////////////////////////////////// No exception is thrown and I can It seem that the lifetime of x1, automatic object, has been extended beyond its "natural" scope. Am I correct? However, if I replace retrival of shared_ptr with weak_ptr then of course bad_weak_ptr exception is thrown: shared_ptr<X> spx; weak_ptr<X> wpx; { X x1(7); wpx = x1.get_weak_ptr(); } spx = shared_ptr<X>(wpx); cout << spx->get_i() << std::endl; I'm having problems with understanding of what causes the extention of lifetime of X (so of internal X::i_ object). Is this mechanism similar to binding r-value to "const reference"? I would appreciate if anyone could help me to understand it. References to the C++ standard would be great too. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net Charter Member of OSGeo, http://osgeo.org

7 9

[ptr_container] Questionable strong guarantee of ptr_map::insert()
by Kazutoshi Satoda 05 Sep '09

05 Sep '09

Hi, With current implementation of ptr_map::insert(), if an exception is thrown, the objected pointed by the passed pointer is deleted. Is this really providing strong guarantee as documented? I understand strong guarantee as described here. http://www.boost.org/community/exception_safety.html > The strong guarantee: that the operation has either completed > successfully or thrown an exception, leaving the program state exactly > as it was before the operation started. I think ptr_map::insert() doesn't provide this guarantee because deleting the object is a change of the program state. As more concrete problem, see the attached code. I couldn't find any way to provide strong guarantee for delayed_inserter::insert_ready() using ptr_map. I want ready_value unchanged if an exception is thrown during the insertion. Looking for a solution on a similar situation, I found constructors of shared_ptr. Its documentation clearly says that "If an exception is thrown, delete p is called". And for auto_ptr version, it provides strong guarantee by taking the auto_ptr as non-const reference. I think ptr_map::insert() should follow this manner; document the deletion on exception for raw pointer version, and provide strong guarantee with insert(const key_type& key, std::auto_ptr<U>& x) . The the auto_ptr& version can be a better replacement of the raw pointer version. The required temporary of auto_ptr, instead of key_type, is more expressive (about the purpose of the temporary), and matches the Best Practices shown in the documentation of shared_ptr. http://www.boost.org/libs/smart_ptr/shared_ptr.htm#BestPractices But, introducing the auto_ptr& version seems to cause some change of behavior in client codes using the current pass-by-value version. Is it valid to request (create a ticket) for strong guaranteed (taking auto_ptr&) version while having this compatibility concern? Regards. -- k_satoda #include <memory> #include "boost/ptr_container/ptr_map.hpp" namespace ptr_map_insert_strong_guarantee_demo { class value { public: explicit value(int source); // ... }; class delayed_inserter { public: // ... // This is called from context that knows key and source of value, // but doesn't know the time of insertion. void ready_new(int key, int source) { // OK. // This implementation offers strong guarantee for this call. std::auto_ptr<value> new_value(new value(source)); ready_key = key; ready_value = new_value; } // This is called from context which doesn't know key and value, // but knows the time of insertion. void insert_ready() { if (ready_value.get() != 0) { // I want to offer strong guarantee for this call, // but boost::ptr_map deosn't provide the way to do that; // *** ready_value is deleted when an exception is thrown. *** map.insert(ready_key, ready_value); } } // ... private: int ready_key; std::auto_ptr<value> ready_value; boost::ptr_map<int, value> map; // ... }; }

8 17

[lockfree] how many items are queued?
by Oliver Kowalke 05 Sep '09

05 Sep '09

lockfree.fifo provides the info if the queue is empty or not. is it possible to provide a function std::size_t size() const - returning how many items are queued at a specific timepoint? regards, Oliver -- Jetzt kostenlos herunterladen: Internet Explorer 8 und Mozilla Firefox 3 - sicherer, schneller und einfacher! http://portal.gmx.net/de/go/chbrowser

5 9