February 2010 - Boost - lists.boost.org

[contract] Contract Programming Library
by Lorenzo Caminiti 09 Feb '10

09 Feb '10

Hi all, I am thinking to submit a library for Contract Programming (a.k.a. Design By Contract (TM) ) for C++. I have drafted some of the library documentation in Boost-like format: http://dbcpp.sourceforge.net/boost/libs/contract/doc/html/ Comments? Regards, Lorenzo

6 15

Re: [boost] boost::mpl::for_each and value_initialized
by Niels Dekker - address until 2010-10-10 08 Feb '10

08 Feb '10

>> I'm sorry, MSVC bug #100744 is still there, even though #335987 has >> been fixed. VC9 deals with POD types correctly, but may not do so >> for non-POD aggregate class types. Domagoj Saric wrote: > but if this is so, shouldn't the proposed patch atleast be > modified to: > > #ifdef BOOST_VALUE_INITIALIZATION_NEEDS_MEMSET > if > ( > !( > ( _MSC_VER >= 1500 ) && > ( is_pod<T>::value ) > ) > ) > std::memset(&x, 0, sizeof(x)); > > #endif > ? I would consider that a refinement. But it's not that simple. MSVC does value-initialize a lot of non-POD types correctly! (But not all of them.) Other compilers may value-initialize built-in types correctly, but not aggregates. I can't remember exactly. So I'd rather start by committing the simple fix that I proposed at Aleksey's ticket #3869, "Unconditional call to memset in value_initialized()", https://svn.boost.org/trac/boost/ticket/3869 Note that I'm planning to rename the macro to BOOST_NO_PROPER_VALUE_INITIALIZATION_FOR_ALL_TYPES. I hope that's okay. But before I commit I'll have to write unit tests for this macro, as John explained to me. I'm planning to do so later this month. When all that is done and stabilized, I wouldn't mind looking at some possible fine tuning, to further reduce the number of memset calls. But I'm afraid it will be a maintainer's headache. Kind regards, Niels -- Niels Dekker http://www.xs4all.nl/~nd/dekkerware Scientific programmer at LKEB, Leiden University Medical Center

2 1

[lexical_cast] efficiency
by Domagoj Saric 08 Feb '10

08 Feb '10

'A while back', in the "error_code debate" I used a lexical_cast<> example for demonstrating certain concerns/aspects but the whole post was so long (as usual :) that it was probably read by less than 0.1% of people :) Anyways I'm extracting and reposting this bit now as I think it warrants attention. The first problem is the ('standard') "std::streams vs efficency" issue: - on msvc 9.0 sp1 the single line boost::lexical_cast<int>( "321" ); caused 14 calls to new and 26 calls to EnterCriticalSection() (not to mention vtable initializations, virtual function calls, usage of locales...) the first time it is called, and 3 calls to new and 15 calls to EnterCriticalSection() on subsequent calls...It also caused the binary (which does not otherwise use streams) to increase by 50 kB! ...which is IMNHO abhorrent... (with my usual 'put things in perspective' examples http://www.theprodukkt.com/kkrieger http://www.youtube.com/watch?v=3vzcMdkvPPg :) As a start maybe this problem could be sufficiently "lessened" by providing lexical_cast specializations/overloads that use C library functions (strtol, itoa and the likes) as they suffer less from bloat/performance issues than std::streams. Ideally, IMHO, lexical_cast<> should provide the power/configurability of boost::numeric_cast (so that one can, for example, say I do not need/want to use locales/assume ASCII strings and things like that). The second problem is the use of exceptions (or better of only using exceptions): if, for example, one uses lexical_cast<> deep in the bowels of some parser it is probably "natural" to use a bad_cast exception to report an error to the outside world but if one uses lexical_cast<> to convert a string entered into a widget by a user into an int it would mostly be simpler to have a simple error code if the user entered an invalid string and issue a warning and retry "at the face of the place" (without the need for try-catch blocks)... In other words maybe a dual/hybrid approach of using both exceptions and error codes (through different overloads would be justified). -- "That men do not learn very much from the lessons of history is the most important of all the lessons of history." Aldous Huxley

5 9

boost::mpl::for_each and value_initialized
by Peter Foelsche 08 Feb '10

08 Feb '10

Dear All, what is the use of value_initialized in boost::mpl::for_each? It should be sufficient if the value is initialized by the constructor. value_initialized() calls memset() in before calling the constructor. This memset() is not being optimized away with gnu-c++ 4.4.1. What class does require zeroed memory to work correctly? Peter *** boost_1_40_0/boost/mpl/for_each.hpp Mon Aug 17 22:16:53 2009 --- boost_1_40_0.saved/boost/mpl/for_each.hpp Tue Sep 1 12:54:55 2009 *************** *** 71,78 **** // dwa 2002/9/10 -- make sure not to invoke undefined behavior // when we pass arg. ! value_initialized<arg> x; ! aux::unwrap(f, 0)(boost::get(x)); typedef typename mpl::next<Iterator>::type iter; for_each_impl<boost::is_same<iter,LastIterator>::value> --- 71,78 ---- // dwa 2002/9/10 -- make sure not to invoke undefined behavior // when we pass arg. ! //value_initialized<arg> x; ! aux::unwrap(f, 0)(arg()); typedef typename mpl::next<Iterator>::type iter; for_each_impl<boost::is_same<iter,LastIterator>::value>

5 10

[fusion] is there an adapter for C-arrays?
by vicente.botet 08 Feb '10

08 Feb '10

Hi, I need to visit the members of a C++ type using Fusion sequences. For structures I plan to use BOOST_FUSION_ADAPT_STRUCT. I need also to visit also c-arrays (with static size). I see that there is already an adapter for boost::array. Is there an adapter for C-arrays? Thanks, _____________________ Vicente Juan Botet Escribá

4 11

Re: [boost] boost::mpl::for_each and value_initialized
by Niels Dekker - address until 2010-10-10 07 Feb '10

07 Feb '10

Peter Foelsche wrote: > in boost_1_41_0 there is still an unconditional call to memset in > value_initialized() Fernando Cacciola and I originally added the memset call within value_initialized() for MSVC only, because MSVC's implementation of value-initialization was known to incorrectly leave some bytes uninitialized, in some very relevant use cases. https://svn.boost.org/trac/boost/changeset/39157/trunk/boost/utility/value_… Thereby we also added extra unit tests, which were passed by MSVC by then, because of the memset. But unfortunately they failed on other compilers (GCC, Borland/Codegear and Sun), because of similar value-initialization issues. That's when we thought it was wise to just have the memset call there for all compilers: https://svn.boost.org/trac/boost/changeset/41942/trunk/boost/utility/value_… Do I understand correctly that you want the memset call to be skipped for those compiler versions that have implemented value-initialization entirely correctly? Do you know exactly which compiler versions do implement value-initialization correctly? Personally I do appreciate that the behavior of value_initialized is now exactly the same for all compilers. But I do understand you're concerned about the performance penalty of the memset call, for those compilers that have implemented value-initialization correctly. If so, can you please create a ticket, preferably including a patch? Kind regards, Niels -- Niels Dekker http://www.xs4all.nl/~nd/dekkerware Scientific programmer at LKEB, Leiden University Medical Center

5 8

wrapper to add Boost.Iterator adaptors to Boost.Range
by dstahlke 07 Feb '10

07 Feb '10

I've worked up a subclass that adds Boost.Iterator functionality to a Boost.Range object. The motivation was twofold: Range combines begin() and end() into one object, preventing the need to write iterator adapter code twice, and adding adaptors into the subclass avoids the need to specify namespaces and allows code structures similar to those of perl or ruby. I expect that this type of writing will become desirable when C++0x lambda functions are available. The C++0x 'auto' keyword will allow storing the generated iterators to local variables for further arithmetic; as it stands now the induced types are far to complex to be written out by hand. The point of this message is just to share the idea in case anyone wishes to do something with it. I'm relatively new to C++ and lack the knowledge needed to make something like this the right way. For example, I have no idea how to make the transform_tuple function work with anything other than a two element tuple. The '*' and '+' arithmetic operators have been defined to perform pairwise arithmetic between elements, but it may also make sense to define operators like "magic_iter + scalar" and "magic_iter += magic_iter". With the 'auto' keyword this would allow converting a bunch of STL containers into iterator objects which could then be manipulated mathematically as if they were Blitz++ arrays. /////////////////////////////////////////////// // magic_iter_demo.cpp /////////////////////////////////////////////// #include <magic_iter.h> #include <vector> #include <set> #include <iostream> #include <boost/foreach.hpp> #include <boost/lambda/lambda.hpp> using namespace boost::lambda; int main() { std::cout << "--- odd multiples of 10, reverse sorted\n"; std::vector<int> tmp; BOOST_FOREACH( int x, my::make_magic_counter(0, 10). filter(_1 & 1). transform<int>(_1 * 10). assign_to(tmp). // needed to allow sort sort(_1 > _2) ) { std::cout << x << std::endl; } std::cout << "--- unique elements of v*w, using zip\n"; std::vector<int> v; std::vector<double> w; my::make_magic_counter(0, 11). transform<int>(_1 - 5). assign_to(v). transform<double>(_1 * 0.01). assign_to(w); std::set<double> tmp2; zip(my::make_magic_iter(v), my::make_magic_iter(w)). transform_tuple<double>(_1 * _2). insert_into(tmp2). // uniq for_each(std::cout << _1 << "\n"); std::cout << "--- elements of v*w, using operator\n"; (my::make_magic_iter(v) * my::make_magic_iter(w)). for_each(std::cout << _1 << "\n"); } /////////////////////////////////////////////// // magic_iter.h /////////////////////////////////////////////// #ifndef MAGIC_ITER_H #define MAGIC_ITER_H #include <iterator> #include <algorithm> #include <boost/range/iterator_range.hpp> #include <boost/iterator/transform_iterator.hpp> #include <boost/iterator/filter_iterator.hpp> #include <boost/iterator/zip_iterator.hpp> #include <boost/iterator/counting_iterator.hpp> #include <boost/tuple/tuple.hpp> #include <boost/lambda/lambda.hpp> namespace my { // result_type_wrapper is from mailing list post by Maxim Yegorushkin template <class R, class F> struct result_type_wrapper : F { typedef R result_type; explicit result_type_wrapper(const F &f) : F(f) {} }; template <class R, class F> static inline result_type_wrapper<R, F> result_type(const F &f) { return result_type_wrapper<R, F>(f); } template <class R, class F> struct tuple_lambda_wrapper { typedef R result_type; explicit tuple_lambda_wrapper(const F &_f) : f(_f) { } template <class T> R operator()(const T &tuple_val) const { return f( boost::tuples::get<0>(tuple_val), boost::tuples::get<1>(tuple_val) ); } F f; }; template <class R, class F> static inline tuple_lambda_wrapper<R, F> tuple_lambda(const F &f) { return tuple_lambda_wrapper<R, F>(f); } template <class T> class magic_iter : public boost::iterator_range<T> { public: typedef typename std::iterator_traits<T>::value_type value_type; magic_iter(const T &_begin, const T &_end) : boost::iterator_range<T>(_begin, _end) { } template <class F> magic_iter<boost::transform_iterator<F, T> > transform(const F &f) { return magic_iter<boost::transform_iterator<F, T> >( boost::make_transform_iterator(this->begin(), f), boost::make_transform_iterator(this->end(), f) ); } template <class R, class F> magic_iter<boost::transform_iterator< result_type_wrapper<R, F>, T> > transform(const F &f) { return transform(result_type<R>(f)); } template <class R, class F> magic_iter<boost::transform_iterator< tuple_lambda_wrapper<R, F>, T> > transform_tuple(const F &f) { return transform(tuple_lambda<R>(f)); } template <class C> magic_iter<typename C::iterator> assign_to(C &container) { container.assign(this->begin(), this->end()); return make_magic_iter(container); } template <class C> magic_iter<typename C::iterator> insert_into(C &container) { container.insert(this->begin(), this->end()); return make_magic_iter(container); } template <class F> magic_iter<T> &sort(const F &comparator) { std::sort(this->begin(), this->end(), comparator); return *this; } template <class F> magic_iter<boost::filter_iterator<F, T> > filter(const F &f) { return magic_iter<boost::filter_iterator<F, T> >( boost::make_filter_iterator(f, this->begin(), this- >end()), boost::make_filter_iterator(f, this->end(), this->end()) ); } template <class F> void for_each(const F &f) { std::for_each(this->begin(), this->end(), f); } }; template <class T> magic_iter<typename T::iterator> make_magic_iter(T &container) { return magic_iter<typename T::iterator>(container.begin(), container.end()); } template <class T> magic_iter<typename T::iterator> make_magic_iter(const T &begin, const T &end) { return magic_iter<typename T::iterator>(begin, end); } template <class T> magic_iter<typename boost::counting_iterator<T> > make_magic_counter(const T &begin, const T &end) { return magic_iter<typename boost::counting_iterator<T> >( boost::counting_iterator<T>(begin), boost::counting_iterator<T>(end) ); } template <class A, class B> magic_iter<boost::zip_iterator<boost::tuple<A, B> > > zip(const magic_iter<A> &a, const magic_iter<B> &b) { //return make_magic_iter( return magic_iter<boost::zip_iterator<boost::tuple<A, B> > >( boost::make_zip_iterator( boost::tuple<A, B>(a.begin(), b.begin()) ), boost::make_zip_iterator( boost::tuple<A, B>(a.end(), b.end()) ) ); } template <class X, class Y> struct tuple_multiply { typedef typename boost::lambda::return_type_2< boost::lambda::arithmetic_action< boost::lambda::multiply_action >, X, Y>::type result_type; result_type operator()(const boost::tuple<X, Y> &t) const { const X &x = boost::tuples::get<0>(t); const Y &y = boost::tuples::get<1>(t); return x*y; } }; template <class X, class Y> magic_iter<boost::transform_iterator< tuple_multiply<typename X::value_type, typename Y::value_type>, boost::zip_iterator<boost::tuple<X, Y> > > > operator*(magic_iter<X> x, magic_iter<Y> y) { //magic_iter<boost::zip_iterator<boost::tuple<X, Y> > > zi = zip(x, y); //return zi.transform(tuple_multiply<typename X::value_type, typename Y::value_type>()); tuple_multiply<typename X::value_type, typename Y::value_type> op; return zip(x, y).transform(op); } template <class X, class Y> struct tuple_plus { typedef typename boost::lambda::return_type_2< boost::lambda::arithmetic_action< boost::lambda::plus_action >, X, Y>::type result_type; result_type operator()(const boost::tuple<X, Y> &t) const { const X &x = boost::tuples::get<0>(t); const Y &y = boost::tuples::get<1>(t); return x+y; } }; template <class X, class Y> magic_iter<boost::transform_iterator< tuple_plus<typename X::value_type, typename Y::value_type>, boost::zip_iterator<boost::tuple<X, Y> > > > operator+(magic_iter<X> x, magic_iter<Y> y) { tuple_plus<typename X::value_type, typename Y::value_type> op; return zip(x, y).transform(op); } } // namespace my #endif // MAGIC_ITER_H

3 2

[wave] limited extensibility
by Christopher Lux 07 Feb '10

07 Feb '10

Hi, i am trying to use boost.wave as a preprocessor for OpenGL Shading Language shader files (GLSL). GLSL uses a limited C/C++ preprocessor (no included etc.). I want to use boost.wave to handle the includes correctly besides generally gaining a more powerful preprocessor. Now the problem is that there a special preprocessor directives in GLSL that the compiler itself has to handle. I am speaking of the #version and #extension directives. I hoped boost.wave would provide the possibility to add special directives that the client code then can handle properly. Currently I use the context hook as follows: class glsl_preprocessing_hook : public boost::wave::context_policies::default_preprocessing_hooks { public: template <typename ContextT> void throw_exception(ContextT const &ctx, std::exception const& e) { throw e; } template <typename ContextT> void throw_exception(ContextT const &ctx, boost::wave::preprocess_exception const& e) { // just ignore ill formed directives (version, exception...) and let the glsl compiler handle these if(e.get_errorcode() != boost::wave::preprocess_exception::ill_formed_directive) { throw e; } } }; This just ignores the ill formed directives, but may still let unwanted errors through. Would it be possible to extend boost.wave in a way to be able feed the lexer or context regular expressions of the new custom directives? These could be pushed into a special hook method with the appropriate context information. I think this functionality would greatly increase the usability for C++ like languages with custom extensions to the preprocessor. Regards -chris

2 4

[chrono] v0.3.1 Support for wide characters
by vicente.botet 07 Feb '10

07 Feb '10

Hi, this new version includes: * Added support for wide characters on formatters. * Added chrono.hpp and stopwatches.hpp header files at the boost level. * Update of the doc taking care of preceding comments. Comments are welcome :) Best, Vicente ----- Original Message ----- From: "vicente.botet" <vicente.botet(a)wanadoo.fr> To: <boost(a)lists.boost.org>; <boost-users(a)lists.boost.org> Sent: Sunday, January 17, 2010 9:14 PM Subject: [chrono] v0.3 New Stopwatch Feature Hi, I'm pleased to announce the new version of the Boost.Chrono library. The implementaton is quite stable; the new interface could suffer of some modifications, renaming, ... as far as you submit some proposals. I would request a formal review soon and I will need a review manager. I know that review managers are hard to find, so if you are interested in the library, please the Review Wizards. The library can be downloaded from http://www.boostpro.com/vault/index.php?action=downloadfile&filename=chrono… and the documentation is online on the sandbox http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/html/index.ht…. I've tested it with gcc and MSVC. Previoous version of the library have been testted on Mac, but I'm not able to test this platform. Could someone check if there are some regressions on Mac? New Features: * Process cpu clocks * Independent process cpu clocks for real, user, system process CPU time * Global process cpu clock for real, user, system process CPU time * Stopwatch concept measuring elapsed time between different points in time associated to the operations start, stop, suspend and resume. * stopwatch is a model Stopwatch measuring the elapsed time between the start and the stop operations. * stopwatch_accumulator is a model Stopwatch allowing to accumulate several time samples and give the average, ... * Scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch. * Stopwatch Formatter concept * stopwatch formatter "%ds\n" * stopwatch accumulator formatter "%c times, sum%ss, min%ms, max%Ms, mean%as\n" * time formatter "real %rs, cpu %cs (%p%), user %us, system %ss\n" * digital_time decomposition class separating days, hours,minutes,seconds, nanoseconds from any duration class (looking for a better name) * digital_time formatter "%d days(s) %h:%m:%s.%n\n" * stopwatch_reporter is a convenient generic class reporting elapsed time for the Stopwatch concept. * stopclock<Clock> shortcut stopwatch_reporter<stopwatch<Clcok>> * typeof registration for classes duration and time_point Depreceated Features: * The classes process_times, process_clock, process_timer, timer and run_timer are now deprecated as the preceding additions are more generic. However for backward compatibility they are preserved until inclusion of the library in Boost. Next follows the equivalences: timer<> ~ stopwatch<> process_timer ~ stopwatch<process_cpu_clock> run_timer ~ stopclock<> Bug Fixes * Try to correct warning C4251: 'boost::chrono::run_timer::m_format' : class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface to be used by clients of class 'boost::chrono::run_timer', by don't including inlines functions using the std::string m_format. For people that doesn't know it yet, Boost.Chrono library provides: * The C++0x Standard Library's common_type. * The C++0x Standard Library's compile-time rational arithmetic. * The C++0x Standard Library's time utilities, including: * Class template duration * Class template time_point * Clocks: * system_clock * monotonic_clock * high_resolution_clock * typeof registration for classes duration and time_point * Process clocks: * process_real_CPU_clocks, capturing real-CPU times. * process_user_CPU_clocks, capturing user-CPU times. * process_system_CPU_clocks, capturing system-CPU times. * process_cpu_clock, tuple-like class capturing at once real, user-CPU, and system-CPU times. * Stopwatches: * stopwatch, capturing elapsed Clock times. * stopwatch_accumulator, capturing cummulated elapsed Clock times. * scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch. * Stopclocks or Stopwatch reporters: * stopwatch_reporter, convenient reporting of models of Stopwatch results. * stopclock<Clock> shortcut of stopwatch_reporter<stopwatch<Clock>> Best regards, _____________________ Vicente Juan Botet Escribá

7 9

[thread] small futures patch
by Christopher Lux 07 Feb '10

07 Feb '10

Hi, i came across an annoying compiler warning when using boost.thread (1.42 release) in a 64bit environment. Attached is a small patch for the futures.hpp in the trunk. Regards -chris

1 0