- Boost - lists.boost.org

New version of C++ Middleware Writer now on line
by Brian Wood 14 May '09

14 May '09

Shalom Version 1.9 of the C++ Middleware Writer is now available. This version adds support for Boost Array and it also has a command line interface that allows users to bypass the web interface. In other words, it makes it easy to integrate the C++ Middleware Writer into your build process. http://webEbenezer.net/build_integration.html<http://webebenezer.net/build_integration.html> -- Brian Wood Ebenezer Enterprises http://www.webEbenezer.net <http://www.webebenezer.net/>

1 0

Binary compatibility of boost releases. Is there such a thing at all?
by Alexander Churanov 14 May '09

14 May '09

Hi folks! I am working on boost port for FreeBSD. At present I am investigating into versioning of shared libraries. Historically, versions of boost shared libraries on FreeBSD do not match boost release version. Some FreeBSD folks beleive that application should not be recompiled just because the boost was updated, say from 1.37 to 1.39 and that shared library version for 1.39 may stay the same as it was for 1.37. I'm afraid it's not correct. I've read that there is no binary compatibility for boost shared libraries from different releases, and that application must use exactly the same library it was compiled for. However, these documents are of 2003-2004. Here is the question: What is the actual status of binary compatibility for boost? Alexander Churanov, maintainer of devel/boost

3 3

[future] usage question for new accepted library
by Alan Patterson 14 May '09

14 May '09

Hi, I see Anthony William's future implementation has been accepted over Braddock Gaskill's. I have been using Braddocks implementation and in particular a couple of features which I believe are not in Anthony's implementation. So I am looking for some pointers for how I might do the following with the accepted futures implementation. 1) Using the implicit cast of future<T> to T. I have an application where I can submit jobs to a scheduler, have them executed and provide me with a return value. My scheduler uses a policy for implementation: scheduler<single_threaded_policy> scheduler<threadpool_policy> The user submits a task and gets the result like result_type r = scheduler.submit(some_task()); where result_type is obtained from the scheduler and can either be of type T for single_threaded or future<T> for threadpools. Either way the client doesn't care which, because he can use a T or future<T> identically IF future<T> casts to T. I like this because the client never knows anything about futures, he treats all result_types as type T. I guess the way to do this with the accepted future implementation is to create a template function that does the following: T actual_r = get<result_type>(r); which call get() if it is a future or just returns r if not. But this is no where near as nice IMHO. The user no longer just uses the result_type of his task directly for what seems to be a basic type. 2) callbacks when future is set I have a usage scenario where I submit a batch of tasks where I collect results until I either have the result I want or collect enough that I can return what I have. This is neither a wait_for_any or a wait_for_all, more a kind of wait_until_i_have_enough. I currently implement this by submitting the batch of tasks and getting a batch of futures. I then register a callback on each future that gets called as each future gets set. The callback collects results as they come in and can decide to bail out early if it has enough results. How would I go about implementing this usage with the new futures implementation? Thanks in advance and sorry for the long post. Alan

2 1

Comment spam in bugs
by Sebastian Redl 14 May '09

14 May '09

There's comment spam in this bug: https://svn.boost.org/trac/boost/ticket/1989 Is there a unified way for reporting this, aside from posting here? Sebastian

1 0

[RFC] thread::access_monitor
by Gregory Petrosyan 14 May '09

14 May '09

I would like to hear your comments on the idea behind access_monitor template, which ensures (at compile-time) that data, protected by it, can be accessed only with associated lock held. It can be useful when you want to expose all the native interface of your data type (STL container, for example): in such a case, using ordinary monitor pattern is almost impossible. Example usage: typedef access_monitor<data_type, mutex_type> data_access_monitor; void f(data_access_monitor const& d) { data_access_monitor::value_type const* data; data_access_monitor::lock_type lock; boost::tie(data, lock) = d.const_lock(); // do something with data here } Code: #include <boost/thread.hpp> #include <boost/tuple/tuple.hpp> template <typename T, typename Lockable> struct access_monitor { typedef T value_type; typedef boost::unique_lock<Lockable> lock_type; private: typedef boost::detail::thread_move_t<lock_type> lock_move_type; public: boost::tuple<value_type const*, lock_move_type> const_lock() const { lock_type lock(mutex_); return boost::make_tuple(&data_, lock.move()); } boost::tuple<value_type*, lock_move_type> lock() { lock_type lock(mutex_); return boost::make_tuple(&data_, lock.move()); } private: // mutex_ is guaranteed to be locked when you access data_ mutable Lockable mutex_; T data_; }; Sorry for draft-quality code (however, something like the above compiles with MSVC 9). Please CC me, because I am not subscribed. Gregory

2 1

[random] cross-platform secure seeding methods planned?
by Sebastian Nowozin 14 May '09

14 May '09

Hello everybody, I like the flexibility boost::random offers. However, a severe drawback of the current library is that it does not offer a safe way of generating seeds. Of course the methods for providing this feature would vary quite a lot across platforms (e.g. on some systems its safe to use /dev/random, on some it is not). However, as the library is currently, many users will resort to ad-hoc or unsafe seeding methods instead of implementing a safe solution themselves. Hence, is a cross-platform secure seeding feature planned for boost::random in the future? Thanks, Sebastian

2 1

[exception] Lifetime of exception refered to by exception_ptr
by Adam Badura 14 May '09

14 May '09

I failed to find in Boost.Exception documentation any note on how long is the lifetime of an exception object referred to by an exception_ptr. Also I failed to find it in the referred N2179 (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html) It seems logical to assume that the lifetime is not shorter then the lifetime of any exception_ptr object referring to the exception object. N2179 suggests possibility of use of smart pointer as implementation of exception_ptr which makes that assumption even more justified. However I think that documentation should be explicit with this. Adam Badura

3 5

[iterators] Proof-of-concept for a sentinel iterator adapter
by Beman Dawes 13 May '09

13 May '09

Attached is proof-of-concept code for a sentinel iterator adapter. It turns a pointer to sentinel terminated sequence, such as a C-style string, into a forward iterator with a conforming end iterator. This is more efficient than doing a separate sequence traversal just to find the end. I'm a little surprised that Boost doesn't already have such an iterator adapter. Or am I just missing it? Would a production version of this iterator adapter be a worthwhile addition to Boost.Iterators? Any other comments appreciated, --Beman // sentinel terminated sequence iterator proof-of-concept // Copyright Beman Dawes, 2009 #include <cassert> // sentinel terminated sequence iterator template < class T, T Sentinel = T() > class sentinel_iterator { public: sentinel_iterator() : m_ptr(0) {} // construct end iterator sentinel_iterator( T * p ) : m_ptr( (p && *p != m_sentinel) ? p : 0 ) {} sentinel_iterator & operator++() { assert(m_ptr); if ( *++m_ptr == m_sentinel ) m_ptr = 0; return *this; } T & operator*() const { assert(m_ptr); return *m_ptr; } bool operator==( const sentinel_iterator & rhs ) const { return m_ptr == rhs.m_ptr; } bool operator!=( const sentinel_iterator & rhs ) const { return m_ptr != rhs.m_ptr; } private: T * m_ptr; // 0 == the end iterator static const T m_sentinel = Sentinel; }; int main() { // test cases using default sentinel sentinel_iterator<char> it( "abc" ); assert( it != sentinel_iterator<char>() ); assert( *it == 'a' ); assert( *++it == 'b' ); assert( *++it == 'c' ); assert( ++it == sentinel_iterator<char>() ); sentinel_iterator<char> it2( "" ); assert( it2 == sentinel_iterator<char>() ); sentinel_iterator<char> it3( 0 ); assert( it3 == sentinel_iterator<char>() ); // test cases using non-default sentinel typedef sentinel_iterator<unsigned, -1> my_iter_type; unsigned data[] = { 0, 1, -1 }; my_iter_type my_it( data ); assert( my_it != my_iter_type() ); assert( *my_it == 0 ); assert( *++my_it == 1 ); assert( ++my_it == my_iter_type() ); unsigned my_sentinel = -1; my_iter_type my_it2( &my_sentinel ); assert( my_it2 == my_iter_type() ); my_iter_type my_it3( 0 ); assert( my_it3 == my_iter_type() ); return 0; }

10 23

Boost::Lambda + Boost::Tuple + unresolved overloaded function type
by Dmitry V. Krivenok 13 May '09

13 May '09

Hello! I wrote two simple examples to demonstrate the problem. First one is: //////////////////////////////////////////////////////////////// #include <vector> #include <utility> #include <algorithm> #include <cassert> #include <boost/lambda/lambda.hpp> #include <boost/lambda/bind.hpp> int main() { std::vector<int> v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); std::vector<std::pair<int*, bool> > v2; namespace bll = boost::lambda; std::transform(v1.begin(), v1.end(), std::back_inserter(v2), bll::bind(std::make_pair<int*, bool>, &bll::_1, true)); assert(v2.size() == 3); return 0; } //////////////////////////////////////////////////////////////// This program compiles and works fine. The second program is: //////////////////////////////////////////////////////////////// #include <vector> #include <utility> #include <algorithm> #include <cassert> #include <boost/tuple/tuple.hpp> #include <boost/lambda/lambda.hpp> #include <boost/lambda/bind.hpp> int main() { std::vector<int> v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); namespace bll = boost::lambda; std::vector<boost::tuple<int*, bool> > v3; std::transform(v1.begin(), v1.end(), std::back_inserter(v3), bll::bind(boost::make_tuple<int*, bool>, &bll::_1, true)); assert(v3.size() == 3); return 0; } //////////////////////////////////////////////////////////////// It doesn't compile: $ g++-4.3.2 -I /usr/local/dev/boost-1.38.0/include/ main2.cpp main2.cpp: In function 'int main()': main2.cpp:22: error: no matching function for call to 'bind(<unresolved overloaded function type>, const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::other_action<boost::lambda::addressof_action>, boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1> >, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> > >, bool)' $ What's wrong in the second program? Thank you beforehand! -- Sincerely yours, Dmitry V. Krivenok Orange System Co., Ltd. Saint-Petersburg, Russia work phone: +7 812 332-32-40 cellular phone: +7 921 576-70-91 e-mail: krivenok(a)orangesystem.ru web: http://www.orangesystem.ru skype: krivenok_dmitry jabber: krivenok_dmitry(a)jabber.ru icq: 242-526-443

2 1

Dynamic bitset library - compilation problem on windows (boost 1_37_0onwards)
by Aniket Bhat 13 May '09

13 May '09

I am seeing problems with msvc when compiling a simple code snippet that instantiates a dynamic_bitset with a uint64_t. The problem occurs when instantiating a template specialization for the resize function for uint64_t. There was a change made to the block_width_type typedef from an int in 1_36_0 to block_type in 1_37_0. This change seems to have broken support for uint64_t data-types on 32-bit windows systems or any other types which are bigger than size_t on a given platform. Code snippet: #include <boost/dynamic_bitset.hpp> #include <iostream> #if defined (__GNUC__) #if !defined (SUNOS_OS) typedef unsigned long long uint64_t; #endif #else typedef unsigned __int64 uint64_t; #endif typedef uint64_t myType; boost::dynamic_bitset<myType>::size_type foo() { unsigned int blockHandles(10); return (boost::dynamic_bitset<myType>::size_type )(blockHandles*sizeof(myType)*8); } int main(int argc,char**argv) { boost::dynamic_bitset<myType>::size_type t = foo(); boost::dynamic_bitset<myType> m_myBitSet; m_myBitSet.resize(12,false); } Compilation error: Compiling... TestBitSet.cpp c:\p3_dev_boost\common\lib\boost_1_39_0\boost\dynamic_bitset\dynamic_bitset.hpp(673) : error C2220: warning treated as error - no 'object' file generated c:\p3_dev_boost\common\lib\boost_1_39_0\boost\dynamic_bitset\dynamic_bitset.hpp(649) : while compiling class template member function 'void boost::dynamic_bitset<Block>::resize(boost::dynamic_bitset<Block>::size_type,bool)' with [ Block=myType ] c:\documents and settings\abhat\my documents\aniket\projects\dynamic_bitset\testbitset\testbitset.cpp(17) : see reference to class template instantiation 'boost::dynamic_bitset<Block>' being compiled with [ Block=myType ] c:\p3_dev_boost\common\lib\boost_1_39_0\boost\dynamic_bitset\dynamic_bitset.hpp(673) : warning C4244: 'initializing' : conversion from 'unsigned __int64' to 'const boost::dynamic_bitset<Block>::size_type', possible loss of data with [ Block=myType ] The resize function (dynamic_bitset.hpp:673) calls count_extra_bits() which returns a size_type instead of block_width_type resulting in possible loss of data. At all other places this function is called within the header, it returns a block_width_type. I am not sure if it has to return a size_type in this particular case for a specific reason? Thanks, Aniket.

1 0