November 2010 - Boost - lists.preview.boost.org

bad include guards
by Steven Watanabe 26 Jan '17

26 Jan '17

AMDG The following pairs of files have identical include guards ./boost/concept_check/general.hpp ./boost/concept/detail/msvc.hpp ./boost/concept_check/msvc.hpp ./boost/concept/detail/msvc.hpp ./boost/filesystem/cerrno.hpp ./boost/cerrno.hpp ./boost/interprocess/containers/tree.hpp ./boost/interprocess/containers/detail/tree.hpp ./boost/mpl/min_max.hpp ./boost/mpl/max.hpp ./boost/mpl/vector/aux_/front.hpp ./boost/mpl/list/aux_/front.hpp ./boost/multi_index/identity_fwd.hpp ./boost/multi_index/identity.hpp ./boost/python/pointee.hpp ./boost/python/detail/pointee.hpp ./boost/spirit/phoenix/closures.hpp ./boost/lambda/closures.hpp ./boost/xpressive/proto/v1_/proto_typeof.hpp ./boost/xpressive/proto/proto_typeof.hpp ./libs/config/test/boost_no_dep_nested_class.ipp ./libs/config/test/boost_has_vc6_mem_templ.ipp ./libs/config/test/boost_no_mem_templates.ipp ./libs/config/test/boost_has_vc6_mem_templ.ipp ./libs/config/test/boost_no_std_allocator.ipp ./libs/config/test/boost_has_vc6_mem_templ.ipp ./libs/conversion/test.hpp ./libs/any/test.hpp ./libs/interprocess/example/print_container.hpp ./libs/interprocess/example/printcontainer.hpp ./libs/interprocess/test/expand_bwd_test_template.hpp ./libs/interprocess/test/allocation_test_template.hpp ./libs/interprocess/test/printcontainer.hpp ./libs/interprocess/example/printcontainer.hpp ./libs/interprocess/test/print_container.hpp ./libs/interprocess/example/printcontainer.hpp ./libs/iostreams/test/detail/utf8_codecvt_facet.hpp ./boost/detail/utf8_codecvt_facet.hpp ./libs/regex/test/regress/test_regex_search.hpp ./libs/regex/test/regress/test_partial_match.hpp ./libs/serialization/test/C.hpp ./libs/serialization/test/A.hpp ./libs/xpressive/perf/regex_comparison.hpp ./libs/regex/performance/regex_comparison.hpp ./tools/inspect/time_string.hpp ./tools/common/time_string.hpp In Christ, Steven Watanabe

5 8

Why no non-null smart pointers?
by Ross MacGregor 29 Apr '14

29 Apr '14

I just created a very small smart pointer libary for our project. It will contain two types of shared pointers: SharedHandle and NullableSharedHandle. SharedHandle will be a shared pointer that cannot be null by ensuring a non-null construction while NullableSharedHandle will basically be a typedef for boost::shared_ptr. I firmly believe that code can be made more reliable by minimizing the use of nullable pointers. To this end, I think it is important that we start using non-null pointer types. Ideally the compiler would be able to understand a non-null pointer and catch bugs at compile time, but I think we can still improve things with a few runtime checks. If we make sure that a shared pointer is constructed with a non-null pointer and ban any reset() type methods, we guarentee that it points to something. This can be beneficial for the following reasons: 1. Any function that uses this type will no longer be burdened with precondition checks to make sure variables of this type are not null. 2. It's type is simply more explicit and better explains its function. 3. Moving the non-null check to the creation phase will reduce the possibility of encountering null pointer exceptions at runtime (assuming there are many more pointer references than constructor calls). So my little pointer library seems to make a lot of sense, but if so why hasn't this simple smart pointer variation made it into boost yet? Has this been discussed somewhere already? My search on non-null smart pointers is not revealing much discussion on the topic. Regards, Ross

9 16

[mpl] integral_c [type_traits] integral_constant limits
by vicente.botet 21 Oct '13

21 Oct '13

Hi, I was testing Boost.Ratio with gcc-4.6 c++0x and I get some compile errors when instantiating std::cout << boost::mpl::integral_c< boost::intmax_t, boost::integer_traits<boost::intmax_t>::const_max >::value ; ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp: In instantiation of 'mpl_::integral_c<long long int, 0x7fffffffffffffffll>': ratio_io\ratio_io.pass.cpp:24:6: instantiated from here ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp:72:96: warning: integer overflow in expression [-Woverflow] ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp:72:96: error: '-0x8000000000000000ll' is not a valid template argument for type 'long long int' because it is a non-constant expression ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp:72:96: error: '-0x8000000000000000ll' is not a constant expression integral_wrapper.hpp:72 contains typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next; The same line pass with gcc-4.6, gcc-4.5 and gcc-4.5 c++0x with just a warning. ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp: In instantiation of 'mpl_::integral_c<long long int, 0x7fffffffffffffffll>': ratio_io\ratio_io.pass.cpp:23:6: instantiated from here ..\..\..\../boost/mpl/aux_/integral_wrapper.hpp:72:96: warning: integer overflow in expression [-Woverflow] integral_c is by integral_constant, but integral_constant doesn't needs next a prior types. This means that with the current implementation we can not use integral_constant with the max value of the type. Do you think this is a bug in integral_constant? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

4 6

De Bruijn Bind (alternate bind syntax) Interest?
by David Sankel 24 Jun '13

24 Jun '13

Hello all, I've been working on an alternate bind syntax based on De Bruijn indices[1]. The syntax is very simple, yet the terms are very powerful. Here is an example of a function const that takes in an argument c and returns another function that, for all input, returns c: //λx.λy.x = λλ1 with De Bruijn indices. auto const_ = abs<1>( abs<1>( var<1,0>() ) ); More examples, further explanation, and an implementation are available here[2]. I'm thinking that this library could also be useful as a core for more syntax heavy bind variations. David [1] http://en.wikipedia.org/wiki/De_Bruijn_index [2] http://bitbucket.org/camior/de-bruijn-bind/ -- David Sankel Sankel Software www.sankelsoftware.com 585 617 4748 (Office)

11 73

[config] consexpr workaround
by vicente.botet 21 Mar '13

21 Mar '13

Hi, in order to make easier the introduction of constexpr in a portable way I would like we add a Boost Config workarround. We can define some macros depending on whether BOOST_NO_CONSTEXPR is defined or not. #if defined(BOOST_NO_CONSTEXPR) #define BOOST_CONSTEXPR #define BOOST_CONSTEXPR_OR_CONST const #else #define BOOST_CONSTEXPR constexpr #define BOOST_CONSTEXPR_OR_CONST constexpr #endif For most of the constexpr functions or constructors BOOST_CONSTEXPR will work. constexpr tuple(); =versus= BOOST_CONSTEXPR tuple(); When used for static constants BOOST_CONSTEXPR_OR_CONST is needed as we need to preserv the const keyword when consexpr is not available. static constexpr UIntType xor_mask = a; =versus= static BOOST_CONSTEXPR_OR_CONST UIntType xor_mask = a; We could also add a STATIC_CONSTEXPR macro #define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST static constexpr UIntType xor_mask = a; =versus= BOOST_STATIC_CONSTEXPR UIntType xor_mask = a; For this case the existing macro BOOST_STATIC_CONSTANT could be modified to use BOOST_CONSTEXPR_OR_CONST when static const was used. static constexpr UIntType xor_mask = a; =versus= BOOST_STATIC_CONSTANT(UIntType, xor_mask = a); Can we introduce this workaround? Best regards, Vicente _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

6 17

[parameter] std proposal
by Lorenzo Caminiti 07 Jan '13

07 Jan '13

Hello all, Is there a C++ standard proposal for named parameter addition? I am looking for an "N-paper" for named parameters similar to N2081 for concepts, or N1962 for contracts. Thank you. -- Sent from my mobile device Lorenzo

6 8

[#pragma once]
by Sid Sacek 18 Nov '12

18 Nov '12

I've worked with the MSVC, Sun and GCC compilers. Each one of them supports #pragma once. Is there any reason to wrap this pragma within #ifdefs? Are there any compilers out there today that don't support this #pragma? #if defined( _MSC_VER ) && ( _MSC_VER >= 1020 ) # pragma once #endif Could we change this coding pattern so that it no longer looks like MSVC is being selfish? -Sid Sacek

17 20

[config] explicit call of operator templates / msvc bug workaround
by Stefan Strasser 10 Oct '12

10 Oct '12

Hi, is there already a macro in Boost.Config that allows you to insert the "template" keyword in the following code for those compilers that require it? struct functor{ template<class T> void operator()(); }; template<class F> void g(F f){ f.template operator()<int>(); //(1) works with GCC and comeau f.operator()<int>(); //(2) works with MSVC } this apparently only applies to operator calls. MSVC accepts both (1) and (2) for regular functions. (instantiating the operator template with an object of type T as argument, like mpl::for_each does, is not an option. I can't construct T.) thanks, Stefan

6 10

[interprocess] message_queue hangs when another process dies
by Sergei Politov 03 Nov '11

03 Nov '11

Hi, I have found the following problem with message_queue on win32 (MSVC 2008 + Windows Vista). Suppose we have 2 processes, one sends messages to queue, another reads them. When reading process dies (for instance using End process) during message_queue.receive the another process hangs in send. As I found during investigation, it tries to lock interprocess mutex, but it is already locked by dead process. So this message queue instance becomes unusable. I attached the example. Steps to reproduce: 1) Start "mq.exe s" (i.e. with argument s) It outs: sender: $PID 2) Start mq.exe without arguments. It outs: receiver: $PID 0 1 2 3 4 This time sender outs: send done: 3) At this point the message queue is empty and receiver waits for messages. End it with Task Manager. 4) Enter some number in sender console and press Enter. 5) The sender hangs in message_queue.send Best Regards, Sergei

6 13

[serialization] or [spirit] JSON Archives
by Fernando Pelliccioni 08 Sep '11

08 Sep '11

Hi, After experimenting with Spirit.Qi to make a JSON parser, I had the need for a serializer. First, I thought I could serialize my model of JSON (json:: value, json: object, etc.), but that was not compatible with boost::serialization. I am currently writing a ARCHIVE for Boost Serialization, but I'm finding some problems in order to implement JSON correctly. The question is, does anyone know about some files to Boost Serialization already finished? I've seen the Archive made by Esteve Fernandez, but do not serve my purpose, because I just need JSON. I would like to develop a JSON parser which in turn is a compatible Boost Serialization serializer . Any ideas? Thanks and regards, Fernando Pelliccioni.

5 6

[Opaque] Request for interest in Opaque typedefs library emulation
by vicente.botet 27 Jul '11

27 Jul '11

Hi, I have started to play with a class to define opaque typedefs on funcdamental types. It is based on the C++ proposal " Progress toward Opaque Typedefs for C++0X" by Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf and http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1706.pdf Please take a look on the preceding links to understand the motivation. Boost.Sericalization provide a BOOST_STRONG_TYPEDEF already, but in my opinon the implementation is not complete,as only the order operators are defined (But maybe I'm wrong). Evidently it can not provide everything we can have with a language approach, but IMO this could yet be useful. The library include two class templates (CRTP) to define opaque types: * public_opaque_type<OT,UT> : implicit conversion from OT to UT * private_opaque_type<OT,UT> : no conversion from OT to UT An opaque type (OT) is a new type, different from the underlying type (UT) and other OT. It defines explicit constructor from the UT, and defines all the operators the UT support but this time applied to the OT. To define a new OT with this mixin classes struct serial_number: public_opaque_type<serial_number, unsigned> { BOOST_OPAQUE_PUPLIC_FORWARD_CONSTRUCTORS(serial_number,unsigned); }; struct game_score: private_opaque_type<game_score, unsigned> { BOOST_OPAQUE_PRIVATE_FORWARD_CONSTRUCTORS(game_score,unsigned); }; In addition, defines macros that make this simpler BOOST_OPAQUE_PUBLIC_TYPEDEF(unsigned, serial_number); BOOST_OPAQUE_PRIVATE_TYPEDEF(unsigned, game_score); Next follows the definition of the public_opaque_type template <typename Final, typename T> class public_opaque_type : boost::totally_ordered< Final , boost::integer_arithmetic< Final , boost::bitwise< Final , boost::unit_steppable< Final , boost::totally_ordered< T, Final // public specific conversions , boost::integer_arithmetic< T, Final // public specific conversions , boost::bitwise< T, Final // public specific conversions > > > > > > > { protected: T val_; typedef public_opaque_type opaque_type; public: typedef T underlying_type; explicit public_opaque_type(const T v) : val_(v) {}; public_opaque_type() {}; public_opaque_type(const opaque_type & rhs) : val_(rhs.val_) {} public_opaque_type & operator=(const opaque_type & rhs) { val_ = rhs.val_; return *this; } public_opaque_type & operator=(const T rhs) { val_ = rhs; return *this; } T const& underlying() const { return val_; } T& underlying() { return val_; } operator const T & () const { return val_; } operator T & () { return val_; } #if 0 bool operator==(const opaque_type & rhs) const { return val_ == rhs.val_; } #endif bool operator<(const Final & rhs) const { return val_ < rhs.val_; } Final& operator+=(const Final & rhs) { val_ += rhs.val_; return static_cast<Final&>(*this); } Final& operator-=(const Final & rhs) { val_ -= rhs.val_; return static_cast<Final&>(*this); } ... }; I have started to make some tests and it works well for the moment. Limitations: * As we can not specialize the behaviour of static_cast/dynamic_cast the library sould provide two specific casts opaque_static_cast and opaque_dynamic_static_cast (Not yet implemented). * As operator.() can not be overloaded, it works transparently only for underlying types that don't defines member functions (C++ fundamental types, as int, char, ...). For the others an explicit use of the underlying() member function is needed :( * Others I have not catched yet :( Do you think it is worth continuing? Please, let me know if you see a error on the design. _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

4 8

[filesystem] home_directory_path
by Jeff Flinn 24 Jul '11

24 Jul '11

In looking at implementing a portable home_directory_path function a few questions arise. Based on http://en.wikipedia.org/wiki/Home_directory, POSIX and other UNIX flavors 'appear' to be a straight forward use of the "HOME" environment variable. Does anyone have any experience where the "HOME" variable is not the proper source of the user's home directory? Windows NT and above have the "USERPROFILE" environment variable. Using this would be the easiest to use. But I've seen discussion that this may not always be properly defined, in particular if the user has reset their home directory to a non-system drive. I haven't tracked down it's availability on WinCE. Does anyone have experience with this platform? There is the windows GetUserProfileDirectory api function also available since NT4. This is in the Userenv.lib/dll, obviously adding a link dependancy. How are these sorts of system link dependencies handled? Through bjam? Or is it acceptable/better to use #pragma comment(lib,"Userenv.lib")? In looking at some client code using home_directory_path, I see that they generally are looking for the user's Desktop directory(Mac & Windows). Obviously this only makes sense on GUI platforms. The issue with merely getting this path via home_directory_path() / "Desktop" is IIRC, that at least on windows "Desktop" is localized and may not exist with that name on non-english localized systems. Windows has the SHGetFolderPath api. I need to look into Mac's native support. Any thoughts on the general usefulness of a portable desktop_directory_path? Thanks, Jeff

16 60

[mpl] string to type conversion
by Bartosz Marcinkiewicz 19 Jun '11

19 Jun '11

Hello, I would like to have a macro which could be used like this: STRING_TO_TYPE( MyType ) which would yield: typedef mpl::string<'M','y','T','y','p','e'> MyType_id_t; Any ideas how to implement something like that? Thanks for any help, bma. -- Bartosz Marcinkiewicz tel. (+48) 516 034 243 e-mail: bma(a)epcon.pl, bartosz.marcinkiewicz(a)epcon.pl EPCON Sp. z o.o. www.epcon.pl adres: 53-407 Wrocław, ul. Gajowicka 114/116 tel. (+48) 71 361 75 55 ext.36 fax (+48) 71 361 74 44 NIP PL 899-24-92-498 KRS 0000190187 REGON 932963731 Kapitał zakładowy: 500 000 PLN

4 4

Re: [boost] [date_time] Time zone improvements
by Rutger ter Borg 25 May '11

25 May '11

Jeff Garland wrote: > Very cool :-) One question -- is there a portable solution where a user > could deploy a files onto a Windows system or is it a Unix only solution? > I'm fine with incorporating a *nix only solution because what your > suggesting will be a nice solution for *nix platforms, but it will need to > be clear that it's not portable. I don't see why it wouldn't be possible to deploy the (big-endian) binary files to any platform. Getting it into this binary form (using zone info compiler zic) may be harder to do cross-platform, but cygwin may help here. [snip] > As the primary maintainer of Boost date-time I can say with certainty that > there is interest in this functionality -- it's long been on my todo list > and I haven't had time to get to it. You can email me privately and we > can discuss all the details of how to get your code incorporated. I'll do! Regards, Rutger

5 9

accurate sum accumulator (kahan)
by Gaetano Mendola 27 Apr '11

27 Apr '11

Hi all, I had to implement in terms of boost accumulators the Kahan summation algorithm. I will paste at the end of this message the accumulator, the feature and the extractor source code. This accumulator reduces the numerical error obtained with standard sequential sum, as example the sum of 1e6f elements equal to 1e-6f should give 1.0f, this is the results obtained with sum and sum_kahan: tag::sum: 1.009038925 tag::sum_kahan: 1.000000000 I'm not sure if that sum_kahan is worth to be inserted in the accumulators provided with boost, I'm not an expert of boost:accumulators (I just followed the guide to make this new accumulator) so not sure if you prefer to have a fast_sum and an accurate_sum instead of sum and sum_kahan. Regards Gaetano Mendola // File kahan_sum.hpp #ifndef KAHAN_SUM #define KAHAN_SUM #include <boost/accumulators/framework/accumulator_base.hpp> #include <boost/accumulators/framework/parameters/sample.hpp> #include <boost/numeric/conversion/cast.hpp> namespace boost { namespace accumulators { namespace impl { template<typename Sample> struct sum_kahan_accumulator : accumulator_base { typedef Sample result_type; template<typename Args> sum_kahan_accumulator(Args const & args) : sum(args[sample | Sample()]), compensation(boost::numeric_cast<Sample>(0.0)) { } template<typename Args> void operator ()(Args const & args) { const Sample myTemp1 = args[sample] - this->compensation; const Sample myTemp2 = this->sum + myTemp1; this->compensation = (myTemp2 - this->sum) - myTemp1; this->sum = myTemp2; } result_type result(dont_care) const { return this->sum; } private: Sample sum; Sample compensation; }; }}} namespace boost { namespace accumulators { namespace tag { struct sum_kahan : depends_on< > { typedef impl::sum_kahan_accumulator< mpl::_1 > impl; }; }}} namespace boost { namespace accumulators { namespace extract { extractor< tag::sum_kahan > const sum_kahan = {}; } using extract::sum_kahan; }} #endif

21 68

D-style scope guards?
by Martin Christiansson 07 Mar '11

07 Mar '11

Hi, I have used the good old scopeguard in the past and recently done some experiments with the Boost.ScopeExit library. Still I feel that the clean scope statements in D is missing. It will not be possible to do an equally clean solution without having the same features in the language itself, but I could reach as far as this example that reuses the ScopeExit library: void foo() { GUARDED_SCOPE_BEGIN GUARDED_SCOPE_EXIT() { cout << "Returning from foo()" << endl; } GUARDED_SCOPE_EXIT_END GUARDED_SCOPE_SUCCESS() { cout << "foo(): No Errors occurred!" << endl; } GUARDED_SCOPE_SUCCESS_END GUARDED_SCOPE_FAILURE() { cout << "foo(): Exception caught!" << endl; } GUARDED_SCOPE_FAILURE_END GUARDED_SCOPE_END } The GUARDED_SCOPE_BEGIN macro declares one boolean guard to handle return from several levels of nested scopes and one boolean to guard the current scope from exceptions (will be shadowed in nested scopes). GUARDED_SCOPE_END will set the exception_thrown guard to false before that variable is used by the GUARDED_SCOPE_*() destructors. The latter is actually reused ScopeExit code with an added wrapper with a single if-statement. GUARDED_SCOPE_EXIT() will allways run on scope exit. GUARDED_SCOPE_SUCCESS() will only run if the function is exited with wrapper for return keyword (GUARDED_SCOPE_RETURN). The wrapper must be used since it updates the hidden guard variables. Using plain "return" will behave as if exception was thrown. GUARDED_SCOPE_FAILURE() will run when exception is thrown. There is also a separate GUARDED_SCOPE_NESTED_BEGIN that is supposed to be used for all nested scopes. A reference is kept to the return_called variable in the top-level-scope (variable declared by GUARDED_SCOPE_BEGIN). The biggest issue here is that any extra closing curly bracket inserted between GUARDED_SCOPE_*-definitions and GUARDED_SCOPE_END will cause destructors to run before update of guard variable. Could happen if someone thinks it "looks better" without understanding how stuff works. That kind of error will behave as if exception was thrown. Is this something to investigate further? Messy or potentially useful? Suggestions for improvements? I've appended the contents of my small test program at the end of this email. Can be tested by inserting GUARDED_SCOPE_RETURN() and "throw exception();". Regards, /Martin ----------- #include <iostream> #include <exception> #include <boost/scope_exit.hpp> using namespace std; #define GUARDED_SCOPE_BEGIN bool return_called = false; { bool& return_called_ref = return_called; bool exception_thrown = true; #define GUARDED_SCOPE_NESTED_BEGIN { bool& return_called_ref = return_called; bool exception_thrown = true; #define GUARDED_SCOPE_END exception_thrown = false; (void) return_called_ref; } #define GUARDED_SCOPE_RETURN(rc) { return_called_ref = true; return rc; } #define GUARDED_SCOPE_EXIT(Seq) BOOST_SCOPE_EXIT(Seq) #define GUARDED_SCOPE_EXIT_END BOOST_SCOPE_EXIT_END #define GUARDED_SCOPE_SUCCESS(Seq) BOOST_SCOPE_EXIT( (&return_called_ref) (&exception_thrown) Seq) { if(return_called_ref || !exception_thrown) #define GUARDED_SCOPE_SUCCESS_END } BOOST_SCOPE_EXIT_END #define GUARDED_SCOPE_FAILURE(Seq) BOOST_SCOPE_EXIT( (&return_called_ref) (&exception_thrown) Seq) { if(!return_called_ref && exception_thrown) #define GUARDED_SCOPE_FAILURE_END } BOOST_SCOPE_EXIT_END void foo() { GUARDED_SCOPE_BEGIN GUARDED_SCOPE_EXIT() { cout << "Returning from foo()" << endl; } GUARDED_SCOPE_EXIT_END GUARDED_SCOPE_SUCCESS() { cout << "foo(): No Errors occurred!" << endl; } GUARDED_SCOPE_SUCCESS_END GUARDED_SCOPE_FAILURE() { cout << "foo(): Exception caught!" << endl; } GUARDED_SCOPE_FAILURE_END do { GUARDED_SCOPE_NESTED_BEGIN GUARDED_SCOPE_FAILURE() { cout << "Inner scope: Exception caught!" << endl; } GUARDED_SCOPE_FAILURE_END GUARDED_SCOPE_SUCCESS() { cout << "Inner scope: No Errors occurred!" << endl; } GUARDED_SCOPE_SUCCESS_END GUARDED_SCOPE_END } while(0); GUARDED_SCOPE_END } int main() { try { foo(); } catch(exception& e) { cout << "main(): Caught exception: " << e.what() << endl; return -1; } cout << "main(): No Errors occurred!" << endl; return 0; }

9 16

[scope_exit] MSVC error C2355: 'this' : can only be referenced inside non-static member functions
by Lorenzo Caminiti 01 Mar '11

01 Mar '11

Hello all, I am trying to use Boost.ScopeExit parameter binding mechanism to implement Boost.LocalFunction. To do so, I need to use some internal ScopeExit code to detect the type of `this` and bind its value to the local function declaration. The following code works on GCC but not on MSVC... This appears to be a MSVC 2008 bug: http://connect.microsoft.com/VisualStudio/feedback/details/331418/erroneous… 1) Can anyone please try this code on MSVC versions later than 2008 to see if it was fixed? 2) Do you know of a workaround for this problem? // File: lf03.cpp #include <boost/scope_exit.hpp> struct c { void f() { typedef void (*this_t)(int this_ ); #if defined(BOOST_MSVC) // for MSVC typedef boost::type_of::msvc_typeid_wrapper< sizeof(*boost::type_of::encode_start( #else // for GCC typedef __typeof__( boost::type_of::ensure_obj( #endif boost::scope_exit::aux::wrap( boost::scope_exit::aux::deref( this, (this_t)0 ) ) ) #if defined(BOOST_MSVC) // for MSVC )>::type #else // for GCC ) #endif this_w; } }; int main() { c cc; cc.f(); return 0; } I get this error on MSVC 2008 but the code compiles just fine on GCC: Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42 for 80x86 Copyright (C) Microsoft Corporation. All rights reserved. lf03.cpp using native typeof lf03.cpp(17) : error C2355: 'this' : can only be referenced inside non-static member functions lf03.cpp(22) : error C2955: 'boost::type_of::msvc_typeid_wrapper' : use of class template requires template argument list C:\Program Files\boost\boost_1_42\boost/typeof/msvc/typeof_impl.hpp(212) : see declaration of 'boost::type_of::msvc_typeid_wrapper' Thank you very much. -- Lorenzo

5 8

[serialization] boost/serialization/path.hpp
by Johan Råde 21 Feb '11

21 Feb '11

There is no boost/serialization/path.hpp. I suggest the following: ---------------------------------------------------------------------------------------------------------------- #ifndef BOOST_SERIALIZATION_PATH_HPP #define BOOST_SERIALIZATION_PATH_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) #pragma once #endif #include <boost/config.hpp> #include <boost/filesystem/path.hpp> #include <boost/serialization/level.hpp> BOOST_CLASS_IMPLEMENTATION(boost::filesystem::path, boost::serialization::primitive_type) #ifndef BOOST_NO_STD_WSTRING BOOST_CLASS_IMPLEMENTATION(boost::filesystem::wpath, boost::serialization::primitive_type) #endif namespace boost { namespace serialization { template<class Archive, class String, class Traits> void serialize(Archive& ar, boost::filesystem::basic_path<String, Traits>& p, const unsigned int version) { String s; if(Archive::is_saving::value) s = p.string(); ar & boost::serialization::make_nvp("string", s); if(Archive::is_loading::value) p = s; } }} #endif //-------------------------------------------------------------------------------------------------------------- Comments? Any suggested improvements? --Johan Råde

5 11

Re: [boost] [filesystem] temp_dir_path()
by Domagoj Saric 21 Feb '11

21 Feb '11

"Beman Dawes" <bdawes(a)acm.org> wrote in message news:AANLkTinFigAxpqkbgwQCnOXrr-Jg44=_dep1QWn+hy-Z@mail.gmail.com... > On Tue, Oct 19, 2010 at 3:35 AM, Domagoj Saric <dsaritz(a)gmail.com> wrote: >> Would it be perhaps possible to provide a lower-level function (even in >> the detail namespace) that uses a plain char buffer and an error code, >> that is free of std::vectors, std::strings, boost::paths, >> system::error_codes and >> other things one might not want to pay for (especially if one does not >> use them otherwise) just to make a system API call..? The 'proper' >> version can then wrap the thinner one... > > It would be technically possible, of course, but ... > > What you are really asking for, I think, is a C language interface or > something pretty close to that. The attitude/assumption that anything C++ must implicitly become intimate with the keywords new, virtual and throw otherwise it is actually 'only C' is just plain wrong in the fullest sense of the word: - it is wrong 'factually' not only because (most of) C is a subset of C++ but because it is quite possible to do heavy C++ programming (e.g. so heavy that it causes GCC 4.2.1 to allocate tens of gigabytes of RAM before it eventually kills the entire OS) practically without using any of the before mentioned STL 'goodies'... - it is wrong 'morally' because it is guilty of the typical 'premature pessimization' that feeds the typical anti C++ and anti Boost arguments...IOW Linus will no longer have to ask 'How many memory allocations does it take a C++ programmer to concatenate two strings?' but 'Guess how many tens of kilobytes will calling boost::temp_dir_path() add to your binary?' The 'plain char buffer' can also be understood in a more 'relaxed'/'broader' way to for example also encompass a, more C++ like, iterator_range that specifies a preallocated chunk of storage... > I could have designed the library that way, but didn't want to add a > third way for users to do things, and didn't want to take on the > increased documentation, test, etc, workload. Calling it a 'third way' is bit too hard IMO, why not think of it just as an overload (albeit of a more extreme kind)? -- "What Huxley teaches is that in the age of advanced technology, spiritual devastation is more likely to come from an enemy with a smiling face than from one whose countenance exudes suspicion and hate." Neil Postman

3 2

[C++0x] Emulation of scoped enums
by Beman Dawes 16 Feb '11

16 Feb '11

The improved type safety of the C++0x scoped enum feature is attractive, so I'd like to start using it as it becomes available in compilers. See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a description. Note that the committee changed the name from strongly typed enums to scoped enums. See the attached for a boost/detail header that provides macro wrappers that use scoped enums if available, otherwise fall back on C++03 namespaces and unscoped enums. It lets a library write: BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END ... BOOST_SCOPED_ENUM(algae) sample( algae::red ); void func(BOOST_SCOPED_ENUM(algae)); and then a user can write: sample = algae::green; func( algae::cyan ); Comments or suggestions appreciated, --Beman // scoped_enum_emulation.hpp ---------------------------------------------------------// // Copyright Beman Dawes, 2009 // Distributed under the Boost Software License, Version 1.0. // See http://www.boost.org/LICENSE_1_0.txt // Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x // scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_SCOPED_ENUMS // macro is used to detect feature support. // // Caution: only the syntax is emulated; the semantics are not emulated and // the syntax emulation doesn't include being able to specify the underlying type. // // See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a // description of the feature. Note that the committee changed the name from // strongly typed enums to scoped enums. // // Sample usage: // // BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END // ... // BOOST_SCOPED_ENUM(algae) sample( algae::red ); // void foo( BOOST_SCOPED_ENUM(algae) color ); // ... // sample = algae::green; // foo( algae::cyan ); #ifndef BOOST_SCOPED_ENUM_EMULATION_HPP #define BOOST_SCOPED_ENUM_EMULATION_HPP #include <boost/config.hpp> #ifndef BOOST_NO_SCOPED_ENUMS # define BOOST_SCOPED_ENUM_START(name) enum class name # define BOOST_SCOPED_ENUM_END # define BOOST_SCOPED_ENUM(name) name #else # define BOOST_SCOPED_ENUM_START(name) namespace name { enum enum_t # define BOOST_SCOPED_ENUM_END } # define BOOST_SCOPED_ENUM(name) name::enum_t #endif #endif // BOOST_SCOPED_ENUM_EMULATION_HPP

14 27

[process] How to run test cases
by Boris 23 Jan '11

23 Jan '11

As Boost.Process 0.3 has been released it would be great if the test cases are run on various platforms. So far I've tested Boost.Process on WinXP with MSVC 9.0, Cygwin with g++ 3.4.4 and Solaris with g++ 3.4.6 and Sun C++ 5.9. To make it as easy as possible for others to run the test cases here's a short description of how to proceed. Nearly all test cases depend on a program called "helpers". This program is built first and is started by many test cases as a child process. In order to find the program "helpers" the test cases must know its location. As there is no way to get the location at runtime it is hardcoded in the file libs/process/test/misc.hpp. As the location differs depending on what compiler is used YOU MUST CHECK FIRST THE PATH IN libs/process/test/misc.hpp! Otherwise most of the test cases will fail as they look for a program "helpers" in the wrong directory. As of today only those paths are correct and have been tested which are set for Windows, Cygwin and Solaris. Only after you have checked and maybe updated the path in libs/process/test/misc.hpp you should try to build and run the test cases: WinXP/MSVC 9.0 ************** With MSVC 9.0 you only need to open the Visual Studio 2008 Command Prompt, change to the directory with the test cases and run bjam: C:\boost_1_36_0\libs\process\test> ..\..\..\bjam.exe -q Cygwin/GCC 3.4.4 **************** On Cygwin it's important to know if the Boost libraries have been built for the POSIX or Windows API. By default Boost libraries on Cygwin use the Windows API. With the Windows API the Boost.Process test cases are not passed successfully though (there are compiler errors where I'm not sure currently if they are a Boost.Process problem and how they could be fixed). If you want to run the test cases on Cygwin you must (re-)build the Boost libraries to use the POSIX API: $ cd ~/boost_1_36_0 $ ./bjam cxxflags=-DBOOST_POSIX_API Afterwards you can run the test cases: $ cd ~/boost_1_36_0/libs/process/test $ ../../../bjam cxxflags=-DBOOST_POSIX_API -q Solaris/GCC 3.4.6 ***************** At first you have to put the following line in ~/user-config.jam: using gcc : : : <linker-type>sun ; Then start building the Boost libraries: $ cd ~/boost_1_36_0 $ ./bjam --toolset=gcc cxxflags=-mcpu=ultrasparc For the test cases to be passed successfully you must update Boost.Test. Change line 624 in ~/boost_1_36_0/boost/test/impl/execution_monitor.ipp temporarily to: - , m_CHLD_action( SIGCHLD, catch_system_errors, attach_dbg, alt_stack ) + , m_CHLD_action( SIGCHLD, false, attach_dbg, alt_stack ) It is important that the second parameter is false as the signal SIGCHLD should not be handled by the execution monitor and should not be reported as an error. Afterwards the test cases can be run: $ cd ~/boost_1_36_0/libs/process/test $ ../../../bjam --toolset=gcc cxxflags=-mcpu=ultrasparc -q Solaris/Sun C++ 5.9 ******************* Build the Boost libraries with the sun toolset: $ cd ~/boost_1_36_0 $ ./bjam --toolset=sun stdlib=sun-stlport For the test cases to be passed successfully you must update Boost.Test. Change line 624 in ~/boost_1_36_0/boost/test/impl/execution_monitor.ipp temporarily to: - , m_CHLD_action( SIGCHLD, catch_system_errors, attach_dbg, alt_stack ) + , m_CHLD_action( SIGCHLD, false, attach_dbg, alt_stack ) It is important that the second parameter is false as the signal SIGCHLD should not be handled by the execution monitor and should not be reported as an error. If you run the test cases now you'll get this compiler error for one test case: "../../../boost/asio/detail/socket_ops.hpp", line 218: Error: Cannot assign void* to char*. "../../../boost/asio/detail/socket_ops.hpp", line 229: Error: Cannot assign void* to char*. "../../../boost/asio/detail/descriptor_ops.hpp", line 66: Error: Cannot assign void* to char*. "../../../boost/asio/detail/descriptor_ops.hpp", line 72: Error: Cannot assign void* to char*. The bug has been reported to the Boost.Asio mailing list. If you want to build that one test case, too, you need to fix the two files in Boost.Asio 1.36.0 yourself. All the test cases can be built and run with: $ cd ~/boost_1_36_0/libs/process/test $ ../../../bjam --toolset=sun stdlib=sun-stlport -q

4 9

review request: addition to type_traits library of has_operator_xxx
by Frédéric Bron 19 Jan '11

19 Jan '11

I would like to propose to your review the following addition to the type_traits library, available at the following addresses: https://svn.boost.org/trac/boost/browser/sandbox/type_traits http://dl.free.fr/lRm4VL6WP/type_traits.tar.bz2 The purpose of the addition is to add type traits to detect if unary and binary operators can be applied to given types. For example, is "x<y" or "!x" or "x+y" meaningful? If required, the return type of such an expression is checked to know if it is convertible to a given type. Default behaviour is to not check the return type. The following traits are added: // binary operators: template < typename LHS, typename RHS=LHS, typename RET=void > == has_operator_equal_to != has_operator_not_equal_to > has_operator_greater >= has_operator_greater_equal < has_operator_less <= has_operator_less_equal + has_operator_plus - has_operator_minus * has_operator_multiplies / has_operator_divides % has_operator_modulus && has_operator_logical_and || has_operator_logical_or & has_operator_bit_and | has_operator_bit_or ^ has_operator_bit_xor // unary operators: template < typename RHS, typename RET=void > + has_operator_unary_plus - has_operator_unary_minus ! has_operator_logical_not This new version reflects the discussions we had on the list: http://thread.gmane.org/gmane.comp.lib.boost.devel/194625 In particular about the check or not of the return type. All operators are now included and not only comparison binary operators. Example: has_operator_less<LHS, RHS, RET>::value_type is the type bool. has_operator_less<int> inherits from true_type. has_operator_less<int, int, std::string> inherits from false_type. has_operator_unary_minus<int, long> inherits from true_type. has_operator_unary_minus<double, int> inherits from true_type. has_operator_unary_minus<int, std::string> inherits from false_type. Documentation is accessible at libs/type_traits/doc/html/index.html in the archive. Regards, Frédéric PS: tested with g++ 4.4.5 on i686-linux.

14 53

[Boost][BGL] New isomorphism test algorithm contribution
by Carlos Cardeñosa Pérez 17 Jan '11

17 Jan '11

Hi, I have been developing a new implementation for test graphs isomorphism, named conauto <http://sites.google.com/site/giconauto/> algorithm (based on José Luis López Presa thesis). I would like to contribute it to BGL. This is a more efficient algorithm than the current one. You can study all its details from conauto thesis at here<http://www.diatel.upm.es/jllopez/tesis/thesis.pdf> . Once developed the first conauto BGL-style version, I am sure that there are many advises and comments that could help to enhance it and eventually will be acceptable for BGL maintainers. Find attached both the source code and some measurements graphics. Please, do not hesitate ask me for any additional information. Best regards, Carlos Cardeñosa.

2 7

[system][chrono] header-only libs
by vicente.botet 06 Jan '11

06 Jan '11

Hi, after discussion with Ion about whether Boost.Interprocess could use Boost.Chrono and Boost.System he has found as major drawback that both are not header-only libs. I have implemented Boost.Chrono as a header only lib. If the user wants Boost.Chrono be a header-only lib s/he needs to define the BOOST_CHRONO_INLINED macro. While this could be useful, there is a problem as Boost.Chrono depends on Boost.System that is not a header-only lib. * I have added this on the configuration file #ifdef BOOST_CHRONO_INLINED #define BOOST_CHRONO_INLINE inline #define BOOST_CHRONO_DECL #else #define BOOST_CHRONO_INLINE // as before #endif * Copied all the .cpp files to the detail/inlined directory. * Renamed the .cpp file by .hpp files * Included in the old .cpp files the corresponding .hpp file in the detail/inlined directory * I've replaced the prefix suffix as follows: #ifndef BOOST_CHRONO_INLINED #include <boost/config/abi_prefix.hpp> // must be the last #include #endif #ifndef BOOST_CHRONO_INLINED #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas #else #include <boost/chrono/detail/inlined/file_name.hpp> #endif * prefixed the definitions of the function in the .cpp files by BOOST_CHRONO_INLINE While doing this I have found a minor issue on Windows platform. I hve nedeed to sorrounded by () all the use of min and max functions on the test files to avoid the macros defined on the windows.h file. That means that a header-only lib could break user sources as it will include implicitly some platform files. Another drawback that I have no inspected yet could be the increase in size and compilation time of the user code. Beman do you mind if I try to make your library configurable as header-only, so Ion could use Boost.System and Boost.Chrono and preserve Boost.Interprocess as a header-only lib? Best, Vicente P.S. You can see the sandbox for the last modifications _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

8 23

[Review] Formal Review of Proposed Boost.Chrono Library Starts TOMORROW
by Anthony Williams 05 Jan '11

05 Jan '11

Hi everyone, The review of Vicente Botet's Chrono library starts TOMORROW (November 6th) and lasts until November 15th unless an extension occurs. What is it? ======== Boost.Chrono aims to implement the new time facilities in C++0x, as proposed in N2661 - A Foundation to Sleep On (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm) That document provides background and motivation for key design decisions and is the source of a good deal of information in this documentation. See the current C++0x working draft at http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf for details of what was accepted. The Boost.Chrono library provides: * A means to represent time durations: managed by the generic duration class . Examples of time durations include days, minutes, seconds and nanoseconds, which can be represented with a fixed number of clock ticks per unit. All of these units of time duration are united with a generic interface by the duration facility. * A type for representing points in time: time_point. A time_point represents an epoch plus or minus a duration. The library leaves epochs unspecified. A time_point is associated with a clock. * Several clocks, some of which may not be available on a particular platform: system_clock, monotonic_clock and high_resolution_clock. A clock is a pairing of a time_point and duration, and a function which returns a time_point representing now. * To make the timing facilities more generally useful, Boost.Chrono provides a number of additional clocks that are thin wrappers around the operating system's time APIs, thereby allowing the extraction of read (wall clock) time, user CPU time, system CPU time, - process_real_cpu_clock, captures real (wall clock) CPU times. - process_user_cpu_clock, captures user-CPU times. - process_system_cpu_clock, captures system-CPU times. - A tuple-like class __process_cpuclock_, that captures real, user-CPU, and system-CPU times together. - A thread_clock thread monotonic clock, when supported by a platform. * Boost.Chrono also includes typeof registration for duration and time_point to permit using emulated auto with C++03 compilers. * Boost.Chrono also provides I/O for duration and time_point. It builds on <boost/ratio/ratio_io.hpp> to provide readable and flexible formatting and parsing for types in <boost/chrono.hpp>. The duration unit names can be customized through a new facet: duration_punct. Getting the library ============= The latest version of this library may be downloaded from vault: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=chrono… SVN: http://svn.boost.org/svn/boost/sandbox/chrono Boost.Chrono depends on Boost.Ratio http://www.boostpro.com/vault/index.php?action=downloadfile&filename=ratio.… and optionaly Boost.System Header Only http://www.boostpro.com/vault/index.php?action=downloadfile&filename=system…. and the docs may be viewed here HTML: http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/html/index.ht… PDF: http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/chrono.pdf You can get all these information also (which should avoid some long links) from http://svn.boost.org/trac/boost/wiki/LibrariesUnderConstruction#Boost.Chrono Writing a review ================ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager. Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick - reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Anthony Review Manager for the proposed Boost.Chrono library -- Author of C++ Concurrency in Action http://www.stdthread.co.uk/book/ just::thread C++0x thread library http://www.stdthread.co.uk Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk 15 Carrallack Mews, St Just, Cornwall, TR19 7UL, UK. Company No. 5478976

9 32

[smart_ptr] enable_shared_from_this and multiple inheritance solution
by Philippe Cayouette 03 Jan '11

03 Jan '11

Fellow boosters, A little while ago I found a pernicious problem with enable_shared_from_this when used with multiple inheritance. Here is an example: #include <boost/smart_ptr.hpp> #include <boost/enable_shared_from_this.hpp> class Base1 : public boost::enable_shared_from_this< Base1 > { public: Base1() {} virtual ~Base1() {} boost::shared_ptr< Base1 > GetBase1() { return shared_from_this(); } }; class Base2 : public boost::enable_shared_from_this< Base2 > { public: Base2() {} virtual ~Base2() {} boost::shared_ptr< Base2 > GetBase2() { return shared_from_this(); } }; class Derived : public Base1, public Base2 { }; int main() { boost::shared_ptr< Derived > wDerived(new Derived()); // Either of the following lines crashes with GCC, but the first one // passes on VS2005 boost::shared_ptr< Base1 > wBase1 = wDerived->GetBase1(); boost::shared_ptr< Base2 > wBase2 = wDerived->GetBase2(); return 0; } Since Derived inherits from two bases that each inherits from enable_shared_from_this, it has two internal weak_ptr. These weak_ptr are usualy initialised in the constructor of the shared_ptr and I have observed two different behavior with the above code depending if I build it with VS2005 or GCC. With VS2005, the first base class in the inheritance list of Derived (here Base1) get its internal weak_ptr initialized, but not the second one, thus it crashes when we try to access the Base2 weak_ptr via shared_from_this. On GCC, neither base classes get their internal weak_ptr initialized and both base classes access to their internal weak_ptr provokes a crash. To prevent that kind of problem, I created a SmartPtrBuilder and a (very) slightly modified EnabledSharedFromThis (only one assert was removed). Here is the same program with the modifications: #include <boost/smart_ptr.hpp> #include "EnableSharedFromThis.h" #include "SmartPtrBuilder.h" class Base1 : public Generic::EnableSharedFromThis< Base1 > { public: Base1() {} virtual ~Base1() {} boost::shared_ptr< Base1 > GetBase1() { return SharedFromThis(); } }; class Base2 : public Generic::EnableSharedFromThis< Base2 > { public: Base2() {} virtual ~Base2() {} boost::shared_ptr< Base2 > GetBase2() { return SharedFromThis(); } }; class Derived : public Base1, public Base2 { public: // Factory method static boost::shared_ptr< Derived > Create() { return Generic::SmartPtrBuilder::CreateSharedPtr< Base1, Base2 >(new Derived()); } private: Derived() {} }; int main() { boost::shared_ptr< Derived > wDerived = Derived::Create(); // No more crashes boost::shared_ptr< Base1 > wBase1 = wDerived->GetBase1(); boost::shared_ptr< Base2 > wBase2 = wDerived->GetBase2(); return 0; } As you can see, Derived has now a factory method that uses the SmartPtrBuilder to create the shared_ptr. Two template arguments are used on CreateSharedPtr, allowing it to initialize the internal weak_ptr of each base classes. The SmartPtrBuilder I did can support up to 10 base classes as template arguments and I also did a variadic template version which has no limit. By using the factory method, the users of Derived don't need to know which of its base classes need its internal weak_ptr need to be initialized. Source code for the SmartPtrBuilder and the modified EnableSharedFromThis: http://spoluck.ca:8000/boost/EnableSharedFromThis.h http://spoluck.ca:8000/boost/SmartPtrBuilder.h That builder might be incorporated to the boost smart pointer library so that anyone could use its facilities to prevent the problem mentioned earlier. No modification to the mighty shared_ptr class required, only the addition of a builder. What do you think? Philippe

3 7

[SoC] BGL project idea
by Gautam Sewani 03 Jan '11

03 Jan '11

Hi, I am a Computer Science student hoping to contribute to Boost for this year's summer of code. I had a few questions regarding the BGL project idea (https://svn.boost.org/trac/boost/wiki/SoC2010#Boost.Graph) for SOC 2010. 1. I can think of only a few places where the suggested algorithms will be used. Does the community think that these algorithms are used frequently enough to put them in a library? How important does the community consider this project? 2. Will the project proposal be expected to include the API design? Thanks and Regards Gautam

5 29

[Review][Ratio] Boost.Ratio has been ACCEPTED
by Anthony Williams 01 Jan '11

01 Jan '11

Hi, I am pleased to announce that Boost.Ratio has been ACCEPTED into Boost. There were not as many reviews for Boost.Ratio as for some libraries, but they were overwhelmingly positive. Boost.Ratio is an important building block for other upcoming submissions, and provides an implementation of the C++0x rational arithmetic facilities. A few changes were requested by the reviewers, which I will list below. I know that Vicente has already started working on some of these. These changes should be addressed before the library appears in a Boost release. * Some of the macros had names with RATIO_RATIO in. These should be changed to just RATIO * The ratio_add, ratio_sub, ratio_multiply and ratio_divide templates should derive from the resulting ratio type as well as providing the nested ::type member, in order to closely emulate the template alias facility from C++0x * The typos in the documentation should be fixed, and the documentation reviewed for correctness and clarity (though several of the reviewers made positive comments on the quality of the documentation). * The library needs more tests under the Boost Software License. * All references to names from the boost namespace should be qualified with boost:: to avoid potential name clashes and ambiguity with names from the global namespace. * Sections commented out with #if 0 should be removed * The extensions beyond the facilities required by the C++0x draft should be able to be enabled or disabled through use of a configuration macro. * References to the tests, examples and documentation from within the code should be checked for correctness. I would like to thank Vicente for submitting the library and those that took the time to write a review. Anthony -- Author of C++ Concurrency in Action http://www.stdthread.co.uk/book/ just::thread C++0x thread library http://www.stdthread.co.uk Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk 15 Carrallack Mews, St Just, Cornwall, TR19 7UL, UK. Company No. 5478976

2 2

[Bug Sprint] The Boost bug sprint has begun!
by Marshall Clow 18 Dec '10

18 Dec '10

As of 7 AM PDT, there are 939 open bugs. [ I see that Vicente and Mattias have already started - that's great! ] General information about the bug sprint is here: https://svn.boost.org/trac/boost/wiki/BugSprintNov2010 General information about how the Trac system works is here: https://svn.boost.org/trac/boost/wiki/TicketWorkflow If you're looking for some way to contribute, I would suggest looking at the oldest active tickets, <https://svn.boost.org/trac/boost/report/1?sort=created&asc=1&page=1> and see if they are still valid. There are about 90 active tickets from 2005-2007. [ Many of them are feature requests, but there are bugs there too. ] Here are a couple of summary tables to give you an idea of where we are: https://svn.boost.org/trac/boost/report/20 Type Tickets Bugs 549 Feature Requests 250 Patches 99 Tasks 28 Support Requests 13 https://svn.boost.org/trac/boost/report/21 Milestone Tickets To Be Determined 352 Boost 1.43.0 102 Boost 1.44.0 98 Boost 1.42.0 75 Boost 1.36.0 50 Boost 1.40.0 48 Boost 1.39.0 44 <blank> 41 Boost 1.41.0 40 Boost 1.38.0 30 Boost 1.37.0 25 Boost-1.45.0 15 Boost-1.46.0 11 Website 1.X 4 Boost-1.47.0 1 Boost.Jam 3.1.18 1 Boost.Jam 4.0.0 1 https://svn.boost.org/trac/boost/report/19 Component Tickets date_time 61 thread 50 Python 48 filesystem 42 build 40 asio 38 mpl 38 smart_ptr 37 Useful reports: https://svn.boost.org/trac/boost/report/1 -- full list of tickets https://svn.boost.org/trac/boost/report/18 -- ticket counts by owner https://svn.boost.org/trac/boost/report/19 -- ticket counts by component https://svn.boost.org/trac/boost/report/20 -- ticket counts by ticket type https://svn.boost.org/trac/boost/report/21 -- ticket counts by milestone -- Marshall

6 12

Provisional Boost.Generic and Boost.Auto_Function (concepts without concepts)
by Matt Calabrese 16 Dec '10

16 Dec '10

For those of you who were following the Boost.Auto_Function call for interest, this thread sort of spawned off of that. Boost.Generic (not a part of boost) is a C++0x library intended to replace BCCL as a way of specifying concepts and concept maps, and, when used in conjunction with Boost.Auto_Function (also not a part of boost, though it's in the sandbox and has online documentation at http://www.rivorus.com/auto_function ) as a way to get concept-based function template overloading. For anyone who followed the original thread, I'm happy to say that I'm just a few days away from being able to fully and automatically recognize standard library and user-defined iterator types, though I've had a [not so] surprising amount of compiler crashes and workarounds along the way. For an example of how concept mapping will look (revised from earlier versions as I've made much more progress with implementation), see http://codepaste.net/n47ocu And for an example of how this will be used by Boost.Auto_Function, see http://codepaste.net/1faj21 . At this point I'm not trying to do the equivalent of what would have been C++0x "scoped" concept maps, though at some point I may try to support them, but it would imply calling algorithms through macro invocations (yuck). During development, I've come to some realizations that I'd like discussion about here, mostly concerning concept map lookup and ODR. Essentially, the way the library works is by assembling a compile-time list of concept maps piecewise throughout a translation unit for a given type or combination of types via a clever use of overload resolution that I talked about briefly in the BOOST_AUTO_FUNCTION call for interest thread. Underneath the hood, there is something that resembles tag-dispatching, however it is all done entirely within decltype. In short, the way the concept-based overloading works is that the macro used for specifying a function that dispatches based on concept maps generates something along the lines of this. The "magic" shown in comments is something I'm able to already do, as talked about in the other thread: ///// template< class It > void foo( It&& it ) { typedef decltype ( function_returning_type_with_a_nested_static_function ( /* magical way to get a type that inherits from all concept tags */() ) ) fun_holder; fun_holder::impl( std::forward< It >( it ) ); } ///// Now, this is great, but I'm wondering what this means with respect to ODR. If the user is working with the algorithm "correctly", the typedef will resolve to the same type regardless of the translation unit, however, the "path" taken when inside of the decltype via overload resolution may vary depending on the translation unit when different, orthogonal concept maps are specified for the same type in one translation unit but not in the other (or if concept maps are specified in a different order I.E. via different #include orders). My question is, does this violate ODR in any meaningful sense? Since technically the typedefs should resolve to the same type in each translation unit, not including user error, is there a problem? The next question is much more devious and I have a feeling implies a blatant violation of ODR. Consider the following code, assuming "foo" does concept-based dispatching in a way similar to the above: ///// foo( 5 ); /* a concept map that specifies "int" models a concept that may affect dispatching */ foo( 5 ); ///// With the definition of foo given above, what would effectively happen is that the second call to "foo" will not be able to dispatch based on the new concept map! The reason why is because both calls will use foo< int >, and since it was already instantiated once for int, that first definition will be used. Note that this problem technically even exists with traditional tag dispatch, though I wonder if there may be some sort of solution that is standard. A hackish workaround I've come up for this is if we change the defintion of "foo" to be generated as the following: ///// // Uses C++0x function template default arguments template< class It, class TagType = /* magical way to get a type that inherits from all concept tags */ > void foo( It&& it ) { typedef decltype ( function_returning_type_with_a_nested_static_function ( TagType() ) ) fun_holder; fun_holder::impl( std::forward< It >( it ) ); } ///// Going back to the example calling code, "foo" will now correctly dispatch differently if the intermediate concept map should affect concept-based dispatch. This might seem like a perfect solution, but now we are pretty much definitely violating ODR, since a function that calls "foo" in different translation units will very possibly see different TagTypes even though the overload resolution internal to "foo" would resolve the same. Am I clear on this problem and why I believe my solution only works if you don't consider ODR violations? The final solution that I believe sidesteps all ODR violations would be if I force calls to such algorithms to be done via a macro. The macro would internally do the trick that is currently shown inside of the definition of "foo", only it would now do it at the caller's scope. If I decide to eventually try to support scoped concept maps I would be forced down such a route anyway, so my question ends up being at what point does the library cease being a convenience? Is it worth supporting concepts as accurately as possible, including the above desired behavior, if the calling code has to become: ///// BOOST_GENERIC_CALL( (foo)( 5 ) ); /* a concept map that specifies "int" models a concept that may affect dispatching */ BOOST_GENERIC_CALL( (foo)( 5 ) ); ///// or, if you want a more practical example: ///// BOOST_GENERIC_CALL( (advance)( vector_.begin(), 5 ) ); ///// This is a problem that I would prefer to be resolved sooner rather than later since I want to reduce code rewrites. Any feedback is greatly appreciated, especially if you have insight into these problems. I'll try to get Boost.Generic in its current, very limited form up on the sandbox and the docs online as soon as possible. -- -Matt Calabrese

6 32

Formal Review of IO and Toolbox extensions to Boost.GIL starts TOMORROW
by Mateusz Loskot 11 Dec '10

11 Dec '10

Dear All, According to the Boost Formal Review Schedule [1], review of Christian Henning's extensions to the Boost Generic Image Library (Boost.GIL, [2]), it is: * Boost.GIL.IO * Boost.GIL.Toolbox starts on December 1st and lasts until December 10th, 2010. [1] http://www.boost.org/community/review_schedule.html [2] http://www.boost.org/doc/libs/release/libs/gil/doc/index.html =========== What is it? =========== The Boost.GIL.IO extension provides an easy to use interface for reading and writing various image formats. It also includes a framework for adding new formats. The Boost.GIL.IO is indent to replace the current IO extension which is part of Boost for several years now. Features: * A unified way to read and write image encoded in BMP, JPEG, PNG, PNM, and TIFF formats. The capabilities to read and write in various formats have improved dramatically. * Image data can be provided via standard file or string streams The Boost.GIL.Toolbox provides new color spaces and other small code to ease programming with Boost.GIL. Features: * Implementation of color spaces: Gray_Alpha, HSL, HSV, LAB, and XYZ * Utilities to support dynamic image workflows and color conversions. * Collection of metafunctions to determine alignment, similarity and homogeneity at pixel level. The Boost.GIL as well as the proposed extensions are provided in form of a headers-only library Although, some image formats come with their format dependency, it is corresponding third-party libraries: JPEG - libjpeg PNG - libpng TIFF - libtiff =================== Getting the library =================== The latest version of both extensions can be downloaded as Zip package: http://gil-contributions.googlecode.com/files/boost_review.zip or directly from the Subversion repository: http://code.google.com/p/gil-contributions/source/browse/trunk/gil_2/ and the docs can built as usual with bjam and quickbook tools from within libs/gil/io_new/doc directory The libs/gil/io_new/test/readme.txt provides a step by step guide to configuring, building and running the unit tests. The boost_review.zip is about 20MB due to its extensive collection of test images. They are part of the test suite to make sure that different variations of each image format is read and written correctly. Please, be aware no guarantee can be given that all formats in their all variants are completely supported. ================ Writing a review ================ If you feel the new IO and Toolbox are interesting extensions to the Boost.GIL library, then please submit your review to the developer list (preferably), or to the review manager (mateusz at loskot dot _n_e_t_) Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the extensions? - Did you try to use the extensions? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick - reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the extensions should be accepted as a part of Boost.GIL library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Mateusz Review Manager for the proposed Boost.GIL.IO and Boost.GIL.Toolbox extensions -- Mateusz Loskot, http://mateusz.loskot.net Charter Member of OSGeo, http://osgeo.org Member of ACCU, http://accu.org

9 30

[serialization] boost 1.45. I did not find any information about serios flaw in 1.44
by Sergey Voropaev 09 Dec '10

09 Dec '10

I am reporter of bug #4660 (https://svn.boost.org/trac/boost/ticket/4660) I am glad this bug was fixed in 1.45 version. But I did not find any information in release notes (http://www.boost.org/users/download/version_1_45_0) and in library documentation (http://www.boost.org/doc/libs/1_45_0/libs/serialization/doc/index.html) about what was fixed in 1.44 version. There are not any recommendations or comments about using version 1.44 with binary archives. I think that the absence of such information is very dangerous for the future of the serialization library, since this is a serious indicator of the quality of maintenance of the library. (I have no complaints about the quality of the library and its design) Should I reopen this bug, or open a new one, or this letter would be sufficient to restore order to the documentation of serialization library?

4 4

Library for configuration file parsing
by Denis Shevchenko 04 Dec '10

04 Dec '10

Hi all! Is there any interest in a library for configuration file parsing? I know there is a good library Program_options, but it supports (asit is written in the documentation) "parsing of simple INI-like configuration files". If all you need for configure your programs is INI-like files - use Program_options and forget about this letter. But if you want to use a more complex configuration files, you may be interested in my library, Configurator. simplest.conf: Host = 127.0.0.1 Code for work with this config: cf::configurator configurator; configurator.add_option( "Host" ); configurator.parse( "/some/path/to/simplest.conf" ); std::cout << "Value of host: " << configurator.get_value( "Host" )<< std::endl; Features - Header-only - Allows to set option's default value or/and necessity. - Allows to use arbitrary nesting of sections. - Provides "standard" checks of value's semantic, like correct path, IP validity, email correctness, etc. - Provides "extended" checks of value's semantic, like time period and file size. - Provides common checks of options and sections, like duplication, incorrection, etc. - Supports single-line and multi-line comments (in C++ style). - Allow to register values with multi-values. - Allows to set another "name-value" separator (including space symbol), instead default '='.

23 72

Probing interest in a typed XML traversal library
by Sumant Tambe 02 Dec '10

02 Dec '10

Hello boosters! I'm interested in gauging interest in a typed XML traversal library that combines the succinctness of XPath with the type-safety of XML data-binding tools. I've been developing one such library called LEESA: Language for Embedded Query and Traversal <http://www.dre.vanderbilt.edu/LEESA>. LEESA has several capabilities: 1. Succinct and expressive XPath-like notation for writing object structure traversals 2. Supports child, parent, sibling, descendant, ancestor axes 3. Compile-time schema conformance checking 4. Supports GOF visitors and hierarchical visitors 5. Strategic Programming ... and more! Here are two quick examples comparing XPath and LEESA. More examples are available on the LEESA homepage. XPath expression: "/catalog/book/author/name/text()" LEESA expression: *std::vector<name> author_names = evaluate(root, catalog() >> book() >> author() >> name()); * XPath expression: "//name/text()" LEESA Expression: *std::vector<name> names = evaluate(root, catalog() >> DescendantsOf(catalog(), name())); * The above expressions are checked for schema-conformance at compile-time. LEESA builds these capabilities on top of existing XML data binding tools that generate C++ code from .xsd files. The general process of using LEESA is as follows: 1. Generate C++ classes using your favorite XML data binding tool 2. A python script that comes with LEESA adds a few functions in every generated C++ class. It generates a lot of typedefs and helper functions, which invoke tool generated code. This creates a bridge between LEESA and the code generated by the xml data binding tool. Currently it supports Code Synthesis's xsd and Universal Data Model (UDM) from Vanderbilt University as the underlying code generators. 3. The user includes LEESA.h in his/her C++ program (it is header-only), uses its programming model, compiles, and links with the tool generated code and libraries. So folks, please speak up if you are interested in having such a library in Boost. Thanks, Sumant

3 5

[Bug Sprint] The November bug sprint starts tomorrow!
by Marshall Clow 02 Dec '10

02 Dec '10

The Boost bug sprint starts tomorrow Saturday, November 27, 2010 and runs through Sunday December 5th. The goal of the bug sprint is to make Boost better; the way we measure this is to look at the open tickets in the Trac system. In the last bug sprint (back in June), we closed over 200 tickets. However, in the past five months, the number of open tickets has crept back up, so that we once again have more than 900 open tickets. (the count was down under 800 at the end of the previous sprint). General information about the bug sprint is here: https://svn.boost.org/trac/boost/wiki/BugSprintNov2010 General information about how the Trac system works is here: https://svn.boost.org/trac/boost/wiki/TicketWorkflow Useful reports: https://svn.boost.org/trac/boost/report/1 -- full list of tickets https://svn.boost.org/trac/boost/report/18 -- ticket counts by owner https://svn.boost.org/trac/boost/report/19 -- ticket counts by component https://svn.boost.org/trac/boost/report/20 -- ticket counts by ticket type https://svn.boost.org/trac/boost/report/21 -- ticket counts by milestone -- Marshall

11 25

Getting volunteers' changes back to trunk
by Jim Bell 01 Dec '10

01 Dec '10

Say you have a team of volunteers attacking failed regressions and tickets. They're creating (hopefully) good trunk patches. They can't commit to the trunk, but can modify tickets. If maintainers are active, they could review and incorporate them. But this increased activity may be more of a strain for them. If maintainers are MIA, it won't happen. So we need at least one person to bring these changes back into the trunk. Changes to libraries they're not familiar with. What's the best way for the volunteers to signal to these trunk-authority people to pick up their change? A Ticket keyword and corresponding report should work. Is there a better way? Should we look for a person or two from the volunteers for this role? A regular schedule (say, twice a week) to run the report and patch would be good, I think. Trunk regressions need time to bake. Thoughts?

6 29

Is merging to the release branch allowed again?
by Hartmut Kaiser 01 Dec '10

01 Dec '10

Since I hate holding back merging to the release branch to the last minute before the next release I would like to start doing this asap. Any idea when this might be allowed again? Regards Hartmut --------------- http://boost-spirit.com

6 7

[mpl-cf] [RFC] MPL Real Numbers using Continued Fractions
by Hal Finkel 01 Dec '10

01 Dec '10

Hello, A few months ago, I created an MPL extension type for representing real numbers. The indented use is for compile-time generation of floating-point constants, although it could also be used for MPL-based graph algorithms, etc. The primary design requirement was that almost any compiler would be able to completely inline the conversion to floating-point (which means no functional recursion can be used), and I think I've achieved that. The current implementation uses a modified version of MPL's vector type (modified to add the conversion to floating point, add "overloads", and to remove the typeof-based implementation variant (which is incompatible with the floating-point conversion)). I've posted the code to the Boost vault under the "Template Metaprogramming" section; the file name is boost-mpl-cf-20100531.zip Continued fractions were chosen for the representation because the associated algorithms are simple, and simple proved important for keeping down compilation times. Even so, the compilation times might be too long for practical use. You can decrease the compilation time by using a shorter maximum cf-length by defining BOOST_MPL_LIMIT_CF_SIZE to be 10 instead of 20. The current default is 20 to allow an effective precision near that of a double. Also, continued fractions, being "based on" rational numbers, can exactly represent any rational (for example, 1/3) so the computations can be more accurate than those using a floating-point representation. If you don't know what a continued fraction is, and would like to know, you can check out the wikipedia page: http://en.wikipedia.org/wiki/Continued_fraction The current implementation supports addition, subtraction, multiplication and division, comparison ops, some constants like pi, and I've included sin()/cos() as well. I've not yet written any real documentation, but the archive has a couple of test programs; the usage is pretty simple. Each test program has many individual tests, so its compilation time will be representative of a more-complicated computation, if you just need to do a few things, it would be much faster. If there is interest, I'll add support for generating numbers using metafunctions, write some documentation, jam files, etc. Let me know what you think, and I welcome suggestions, criticisms, etc. Also, I've currently tested using only the GNU and Intel compilers, so let me know whether it does or does not work when using something else. Thanks again, Hal P.S. I know that there is a mpl_math archive on the vault from back in 2007. I did not discover this until after I had almost finished writing my mpl-cf implementation, but, the mailing-list messages from the time indicate that it was too slow to be used practically, since I think the continued fractions algorithms are simpler, mpl-cf might be better, but I've not tested it to find out.

6 11

Re: [boost] Boost 1.45 compile error
by Eric Niebler 01 Dec '10

01 Dec '10

(bringing in boost dev...) This sounds bad. Can anybody confirm? -- Eric Niebler BoostPro Computing http://www.boostpro.com On 11/19/2010 4:35 PM, gast128 wrote: > Hello all, > > just tried out Boost 1.45 on VStudio 2003 but I got a compile error by only > including type_traits: > > #include <boost/type_traits.hpp> > > int main() > { > return 0; > } > > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(160) : error C2027: > use of undefined type '<Unknown>' > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(143) : see > declaration of '<Unknown>' > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(160) : see > reference to class template instantiation '<Unknown>' being compiled > C:\Work Sdk\boost_1_45_0\boost\type_traits\common_type.hpp(121) : see > reference to class template instantiation '<Unknown>' being compiled > C:\Work Sdk\boost_1_45_0\boost\type_traits\common_type.hpp(123) : see > reference to class template > instantiation 'boost::type_traits_detail::common_type_2<T,U>' being compiled > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(160) : error C2146: > syntax error : missing ';' before identifier 'wrapped_type' > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(160) : error > C2501: '<Unknown>' : missing storage-class or type specifiers > C:\Work Sdk\boost_1_45_0\boost\typeof\msvc\typeof_impl.hpp(161) : error > C2653: 'wrapped_type' : is not a class or namespace name > > afaik it seems located on 121 in 'boost/type_traits/coomon_type.hpp' > > Anyone can help?

12 27

[gil] New IO release
by Christian Henning 30 Nov '10

30 Nov '10

Hi there, a new gil IO extension is ready for download. Here is the link: http://code.google.com/p/gil-contributions/downloads/detail?name=boost_revi… This is the final version that will be used for the boost review. Could someone try to build documentation on Linux? Thanks to all people that have helped me out. Regards, Christian

5 18

Sandbox cleanup
by Vladimir Prus 30 Nov '10

30 Nov '10

Folks, it appears that at present, our SVN sandbox is in fairly confused state. A fresh checkout contains objects of very different kinds, in particular: - 'boost' directory, that has assorted headers supposedly meant for future. - 'libs' directory, with various libraries - Pile of top-level directories for libraries-in-development, each containing 'boost' and 'libs' subfolders. - Subdirectory SCons, with a copy of entire Boost tree, buildable with scons. - Subdirectory 'win32-doc-tools', which surely does not contain a library - Some directories named after specific people. It's not clear whether those directories contain a single future library, or several, or what. It seems that a straight-forward approach to fix that is to have two separate areas in sandbox, as follows: [using fixed font to read the below might work better] /sandbox /libraries /proposed-lib1 /boost /libs .... /branches /jrhacker-assorted-fixes [complete branch of trunk, with changes] /SCons [complete branch of trunk, with SConstruct, etc] Comments? -- Vladimir Prus http://vladimir_prus.blogspot.com Boost.Build: http://boost.org/boost-build2

8 9

[Bug Sprint] Status for Tuesday, November 30th
by Marshall Clow 30 Nov '10

30 Nov '10

There were 59 changes to the trac database yesterday. [ I'd like to say "59 tickets were changed", but some tickets were changed more than once. ] A couple of notes: 1) Please log into the Trac system before you add/modify a ticket. "Anonymous said:" is hard to follow up. 2) It is perfectly OK to add a comment to a ticket that says "I tested this patch on my system (foo, gcc 1.2.3.4, etc) and it worked fine/didn't work/etc" General information about the bug sprint is here: https://svn.boost.org/trac/boost/wiki/BugSprintNov2010 General information about how the Trac system works is here: https://svn.boost.org/trac/boost/wiki/TicketWorkflow Overall bug count: November 26: 946 November 27: 939 November 28: 930 November 29: 934 (whoops, that's the wrong direction!) November 30: 931 (better, but the delta is too small) If you want to contribute, I would suggest looking at the old tickets, and seeing what you can do with them: Here are the tickets by milestone: Milestone Tickets To Be Determined 362 Boost 1.43.0 100 Boost 1.44.0 94 Boost 1.42.0 74 Boost 1.36.0 48 <https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=re…> Boost 1.40.0 48 Boost 1.39.0 43 <https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=re…> Boost 1.41.0 39 <blank> 36 Boost 1.38.0 30 <https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=re…> Boost 1.37.0 25 <https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=re…> Boost 1.45.0 13 Boost 1.46.0 12 Website 1.X 4 Boost 1.47.0 1 Boost.Jam 3.1.18 1 Boost.Jam 4.0.0 1 Activities on the trac system yesterday: viboes 16 anonymous 12 ramey 7 mikhailberis 3 marshall 3 --others-- 18 Useful reports: https://svn.boost.org/trac/boost/report/1 -- full list of tickets https://svn.boost.org/trac/boost/report/18 -- ticket counts by owner https://svn.boost.org/trac/boost/report/19 -- ticket counts by component https://svn.boost.org/trac/boost/report/20 -- ticket counts by ticket type https://svn.boost.org/trac/boost/report/21 -- ticket counts by milestone

3 2

virtual protected inheritance and default constructors
by gzp 30 Nov '10

30 Nov '10

Hello, This might be an off-topic question, but there must be here some clever guy who can answer my question. class Impl { public: Impl() { std::cout << "j"; } // want to eliminate, but cannot :( Impl(int j) { i = j; std::cout << "i"; } int i; }; template<typename TImpl> class A : virtual protected TImpl { public: void geti() const { std::cout << "gi" << i << "\n"; } }; template<typename TImpl> class B : public A<TImpl> { public: void seti(int a) { this->i = a; } }; class CA : public A<Impl> { public: CA() : Impl(3) { std::cout << "ca " << i;} }; class CB : public B<Impl> { public: CB() : Impl(2) { std::cout << "cb " << i;} }; //abuse of interfaces template<typename TImpl> void foo( A<TImpl>& p_a ) { p_a.geti(); } template<typename TImpl> void foo( B<TImpl>& p_a ) { p_a.seti( 2 ); } template<typename TImpl> void foo2( A<TImpl>& p_a ) { p_a.geti(); } int main( int, char*[] ) { CA a; std::cout << "\n"; CB b; std::cout << "\n"; foo(a); foo(b); foo2(a); foo2(b); return 0; } The basic concept was that: there is a simple implementation class and using some interfaces (bridge classes) the appropriate function call (foo) can be ensured using compile time type checking. The implementation might provide implementation to multiple interfaces (bridge classes) and these interfaces guarantee the required operation for each (template)functions. The role of A and B is to provide the interface and bridge it to the implementation. The only missing part was, how to construct a CA and CB object. They might have completely different construction parameters and the virtual protected inheritance partially solved the problem. BUT the default constructor is always required (VC2008) even tough it gets never called (I don't want to create any object from A,B (who are missing these default ctors) but I couldn't tell it to the compiler) "The declare and don't define" doesn't solve the problem either as the linker requires the default Impl ctor even though it never gets called. For example: impl1: a range iterator for an 1D array: ctor requires the array.begin, array.end impl2 a random generator range: ctor requires the random seed CA: isEmpty, front, popFront CB: put, mutable front copy from random range to array is valid (template foo(A,B)), but not the other way (no template foo(B,A)) Thanks, Gzp -- View this message in context: http://boost.2283326.n4.nabble.com/virtual-protected-inheritance-and-defaul… Sent from the Boost - Dev mailing list archive at Nabble.com.

1 0

[1.45][filesystem3] utf8 support
by Jochen Wilhelmy 30 Nov '10

30 Nov '10

Hi! now I switched to filesystem3. Everything works, but there is one issue on windows. I'd like to use utf8 in my application. I can imbue an utf8-locale to path. But if I have legacy libraries that take only 8 bit strings then I would pass utf8 instead of ansi (e.g. latin1). Therefore filesystem::path can be seen as a gateway between the application and the operating system and therefore needs two locales, one for the application and one for the operating system. Or an additional method utf8() that returns utf8 regardless of the locale. What do you think? -Jochen

2 1

[thread] On shared_mutex
by Howard Hinnant 30 Nov '10

30 Nov '10

Three years ago I wrote N2406 "Mutex, Lock, Condition Variable Rationale" (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html) for the C++ committee in an attempt to explain the combined proposed std::mutex/std::unique_lock package and how it fit together with the tr2-targeted shared_mutex/shared_lock package. This paper also proposed an upgrade_mutex and upgrade_lock. Since that time, the std-proposed stuff has been accepted with some name changes, and a reworking of the timed-locking interface. Additionally Anthony Williams has implemented much of the shared-locking functionality in boost (and done a very nice job with it). That being said, I disagree with some fairly major design changes between N2406 and what is now in the boost library. Four of the major changes are: 1. upgrade_mutex has been dropped. 2. Some, but not all of the functionality in upgrade_mutex has been moved into shared_mutex. 3. Some of the upgrade_mutex functionality is missing completely. The missing functionality is summarized in the "Ownership Modes" charts in the form of red arrows. 4. boost allows implicit conversions between the lock types. N2406 made these conversions explicit. Rationale: changing the ownership mode of a mutex is something that should be well documented in the code. I have an updated implementation of <shared_mutex> (under the boost license) here: http://home.roadrunner.com/~hinnant/mutexes/shared_mutex http://home.roadrunner.com/~hinnant/mutexes/shared_mutex.cpp There is a tutorial-style description of this library here: http://home.roadrunner.com/~hinnant/mutexes/locking.html The tutorial includes a brief description of the use of most of the components, complete synopses, and an examples section. It also notes where this design differs from the boost design and explains why I believe the boost design is in error. Comments appreciated, and all are welcome to use this code under the boost license. I will likely update this document in response to comments and its date at the top will correctly reflect the last time it was updated. This library, or a variation of it, will probably be submitted to TR2, and so getting feedback on the differences between this and the boost implementation is important. Thanks, Howard

5 17

Re: [boost] Moving Boost.Geometry to trunk (was: Sandbox cleanup)
by Hartmut Kaiser 30 Nov '10

30 Nov '10

> > 1. Declare that /sandbox should follow<library>/{boost,libs} layout. > > 2. Move everything else into /sandbox-branches > > Boost.Geometry follows <library>/{boost,libs,other} layout where other > contains small programs not fitting within libs. I hope this is permitted. > I'm quite dependent on the current place and so are many users. I will > remove the (now obsolete) ggl folder which is still there. > > Maybe it is also possible (now or in the future) to make a distinction > between already-accepted-but-not-yet-incorparted libraries (such as > Boost.Geometry) and proposed libraries. > > Finally there is also /sandbox-tags, of which the structure is also not so > clear to me. I've taken the freedom to create a "geometry" folder there, > and below that are our tags. > > So the there structure is for me: > /sandbox-tags/<library>/<tagname>/{boost,libs} > > And I propose that as a convenient layout. Barend, not really related but a question anyways: why don't you move your overall activities to the trunk? I know you're not satisfied with certain details of your library. However, doing the development on trunk (and Boost.Geometry is an accepted library) gives you more exposure to potential users and full integration with the regression tests. Additionally, having the library on trunk doesn't mean you need to merge it to the release branch for any release in the near future... Regards Hartmut --------------- http://boost-spirit.com

2 1

[Bug Sprint] Status for Monday, November 29th
by Marshall Clow 30 Nov '10

30 Nov '10

There were 37 changes to the trac database yesterday. [ I'd like to say "37 tickets were changed", but some tickets were changed more than once. ] A couple of notes: 1) Please log into the Trac system before you add/modify a ticket. "Anonymous said:" is hard to follow up. 2) It is perfectly OK to add a comment to a ticket that says "I tested this patch on my system (foo, gcc 1.2.3.4, etc) and it worked fine/didn't work/etc" General information about the bug sprint is here: https://svn.boost.org/trac/boost/wiki/BugSprintNov2010 General information about how the Trac system works is here: https://svn.boost.org/trac/boost/wiki/TicketWorkflow Overall bug count: November 26: 946 November 27: 939 November 28: 930 November 29: 934 (whoops, that's the wrong direction!) Activities on the trac system yesterday: anonymous 11 mikhailberis 10 viboes 5 ktchan 4 --others- 7 Useful reports: https://svn.boost.org/trac/boost/report/1 -- full list of tickets https://svn.boost.org/trac/boost/report/18 -- ticket counts by owner https://svn.boost.org/trac/boost/report/19 -- ticket counts by component https://svn.boost.org/trac/boost/report/20 -- ticket counts by ticket type https://svn.boost.org/trac/boost/report/21 -- ticket counts by milestone

7 8

[Preprocessor] Adding variadic macros support
by Mathias Gaunard 30 Nov '10

30 Nov '10

Variadic macros would allow to support tuples better in Boost.PP, as it would not be necessary to specify the size of the tuple, and it could be possible to provide other nice features around tuples. Other possible applications could be to accept the sequence (a)(b, c, d)(e) as being the same as (a)((b, c, d))(e). If you think other things could be improved in PP with variadic macros, feel free to point out where. The question is: how should it be done? Should the new macros be named, say, BOOST_PPV_*? Should the macros in BOOST_PP_* be "overloaded" on arity (a possibility with variadic macros) so as to exhibit both the old and new interface?

10 39

[range] Problem with adaptors::map_keys
by Alexander Fokin 29 Nov '10

29 Nov '10

I'm having some troubles using adaptors::map_keys with custom iterators over Qt associative containers. The problem with Qt associative containers is that they provide iterators over a set of values, not over a set of key-value pairs. I have worked that around by introducing boost range bindings: http://codepad.org/xnZrpZ5i However, when these binding are used, the following code produces a compilation error: BOOST_FOREACH(auto pair, (QMap<int, int>()) | boost::adaptors::map_keys); Everything works fine if the code of boost::range_detail::select_first is slightly modified. You'll find the patch attached. I believe it's a problem in boost range, but I may be wrong, so I need some expert help here. -- Best regards, Alexander Fokin, http://elric.ru.

2 4

[GIL] [patch] read multipage TIFF files
by Robert Pollak 29 Nov '10

29 Nov '10

Hello, the following patch (against the current trunk) allows to read any page of a multipage TIFF file, by optionally specifying the zero-based directory number. (The correct term for a TIFF page is "directory".) It adds a "dirnum" to the relevant functions, and uses the corresponding libtiff functionality. The "dirnum" default value is 0 for compatibility with present callers. Additionally, it defines the function tiff_get_directory_count to get the number of directories in the TIFF file. Please give me some feedback or consider applying the patch. This patch would close the corresponding feature request https://svn.boost.org/trac/boost/ticket/2373 . Credits go to Roland Richter, whose code the patch is based on. Best Regards, Robert Pollak Index: boost/gil/extension/io/tiff_io.hpp =================================================================== --- boost/gil/extension/io/tiff_io.hpp (revision 64065) +++ boost/gil/extension/io/tiff_io.hpp (working copy) @@ -122,9 +122,13 @@ protected: TIFF *_tp; public: - tiff_reader(const char* filename) { + tiff_reader(const char* filename,tdir_t dirnum=0) { io_error_if((_tp=TIFFOpen(filename,"r"))==NULL, "tiff_reader: fail to open file"); + if(dirnum>0) { + io_error_if(TIFFSetDirectory(_tp,dirnum)!=1, + "tiff_reader: fail to set directory"); + } } ~tiff_reader() { TIFFClose(_tp); } template <typename View> @@ -171,10 +175,10 @@ private: CC _cc; public: - tiff_reader_color_convert(const char* filename) : - tiff_reader(filename) {} - tiff_reader_color_convert(const char* filename,CC cc_in) : - tiff_reader(filename),_cc(cc_in) {} + tiff_reader_color_convert(const char* filename,tdir_t dirnum=0) : + tiff_reader(filename,dirnum) {} + tiff_reader_color_convert(const char* filename,CC cc_in,tdir_t dirnum=0) : + tiff_reader(filename,dirnum),_cc(cc_in) {} template <typename View> void apply(const View& view) { point2<std::ptrdiff_t> dims=get_dimensions(); @@ -336,18 +340,34 @@ }; /// \ingroup TIFF_IO +/// \brief Returns the number of directories in the TIFF file +inline int tiff_get_directory_count(const char* filename) { + TIFF *tif; + io_error_if((tif=TIFFOpen(filename,"r"))==NULL, + "tiff_get_count: fail to open file"); + + int dircount = 0; + do { + dircount++; + } while (TIFFReadDirectory(tif)); + + TIFFClose(tif); + return dircount; +} + +/// \ingroup TIFF_IO /// \brief Returns the width and height of the TIFF file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid TIFF file -inline point2<std::ptrdiff_t> tiff_read_dimensions(const char* filename) { - detail::tiff_reader m(filename); +inline point2<std::ptrdiff_t> tiff_read_dimensions(const char* filename,tdir_t dirnum=0) { + detail::tiff_reader m(filename,dirnum); return m.get_dimensions(); } /// \ingroup TIFF_IO /// \brief Returns the width and height of the TIFF file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid TIFF file -inline point2<std::ptrdiff_t> tiff_read_dimensions(const std::string& filename) { - return tiff_read_dimensions(filename.c_str()); +inline point2<std::ptrdiff_t> tiff_read_dimensions(const std::string& filename,tdir_t dirnum=0) { + return tiff_read_dimensions(filename.c_str(),dirnum); } /// \ingroup TIFF_IO @@ -356,17 +376,17 @@ /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template <typename View> -inline void tiff_read_view(const char* filename,const View& view) { +inline void tiff_read_view(const char* filename,const View& view,tdir_t dirnum=0) { BOOST_STATIC_ASSERT(tiff_read_support<View>::is_supported); - detail::tiff_reader m(filename); + detail::tiff_reader m(filename,dirnum); m.apply(view); } /// \ingroup TIFF_IO /// \brief Loads the image specified by the given tiff image file name into the given view. template <typename View> -inline void tiff_read_view(const std::string& filename,const View& view) { - tiff_read_view(filename.c_str(),view); +inline void tiff_read_view(const std::string& filename,const View& view,tdir_t dirnum=0) { + tiff_read_view(filename.c_str(),view,dirnum); } /// \ingroup TIFF_IO @@ -375,25 +395,25 @@ /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its color space or channel depth are not /// compatible with the ones specified by Image template <typename Image> -void tiff_read_image(const char* filename,Image& im) { +void tiff_read_image(const char* filename,Image& im,tdir_t dirnum=0) { BOOST_STATIC_ASSERT(tiff_read_support<typename Image::view_t>::is_supported); - detail::tiff_reader m(filename); + detail::tiff_reader m(filename,dirnum); m.read_image(im); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, and loads the pixels into it. template <typename Image> -inline void tiff_read_image(const std::string& filename,Image& im) { - tiff_read_image(filename.c_str(),im); +inline void tiff_read_image(const std::string& filename,Image& im,tdir_t dirnum=0) { + tiff_read_image(filename.c_str(),im,dirnum); } /// \ingroup TIFF_IO /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its dimensions don't match the ones of the view. template <typename View,typename CC> -inline void tiff_read_and_convert_view(const char* filename,const View& view,CC cc) { - detail::tiff_reader_color_convert<CC> m(filename,cc); +inline void tiff_read_and_convert_view(const char* filename,const View& view,CC cc,tdir_t dirnum=0) { + detail::tiff_reader_color_convert<CC> m(filename,cc,dirnum); m.apply(view); } @@ -401,31 +421,31 @@ /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its dimensions don't match the ones of the view. template <typename View> -inline void tiff_read_and_convert_view(const char* filename,const View& view) { - detail::tiff_reader_color_convert<default_color_converter> m(filename,default_color_converter()); +inline void tiff_read_and_convert_view(const char* filename,const View& view,tdir_t dirnum=0) { + detail::tiff_reader_color_convert<default_color_converter> m(filename,default_color_converter(),dirnum); m.apply(view); } /// \ingroup TIFF_IO /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. template <typename View,typename CC> -inline void tiff_read_and_convert_view(const std::string& filename,const View& view,CC cc) { - tiff_read_and_convert_view(filename.c_str(),view,cc); +inline void tiff_read_and_convert_view(const std::string& filename,const View& view,CC cc,tdir_t dirnum=0) { + tiff_read_and_convert_view(filename.c_str(),view,cc,dirnum); } /// \ingroup TIFF_IO /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. template <typename View> -inline void tiff_read_and_convert_view(const std::string& filename,const View& view) { - tiff_read_and_convert_view(filename.c_str(),view); +inline void tiff_read_and_convert_view(const std::string& filename,const View& view,tdir_t dirnum=0) { + tiff_read_and_convert_view(filename.c_str(),view,dirnum); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid TIFF file template <typename Image,typename CC> -void tiff_read_and_convert_image(const char* filename,Image& im,CC cc) { - detail::tiff_reader_color_convert<CC> m(filename,cc); +void tiff_read_and_convert_image(const char* filename,Image& im,CC cc,tdir_t dirnum=0) { + detail::tiff_reader_color_convert<CC> m(filename,cc,dirnum); m.read_image(im); } @@ -433,23 +453,23 @@ /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid TIFF file template <typename Image> -void tiff_read_and_convert_image(const char* filename,Image& im) { - detail::tiff_reader_color_convert<default_color_converter> m(filename,default_color_converter()); +void tiff_read_and_convert_image(const char* filename,Image& im,tdir_t dirnum=0) { + detail::tiff_reader_color_convert<default_color_converter> m(filename,default_color_converter(),dirnum); m.read_image(im); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. template <typename Image,typename CC> -inline void tiff_read_and_convert_image(const std::string& filename,Image& im,CC cc) { - tiff_read_and_convert_image(filename.c_str(),im,cc); +inline void tiff_read_and_convert_image(const std::string& filename,Image& im,CC cc,tdir_t dirnum=0) { + tiff_read_and_convert_image(filename.c_str(),im,cc,dirnum); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. template <typename Image> -inline void tiff_read_and_convert_image(const std::string& filename,Image& im) { - tiff_read_and_convert_image(filename.c_str(),im); +inline void tiff_read_and_convert_image(const std::string& filename,Image& im,tdir_t dirnum=0) { + tiff_read_and_convert_image(filename.c_str(),im,dirnum); } /// \ingroup TIFF_IO

2 7

Probing interest in a typed XML traversal library
by Sumant Tambe 28 Nov '10

28 Nov '10

Hello boosters! I'm interested in gauging interest in a typed XML traversal library that combines the succinctness of XPath with the type-safety of XML data-binding tools. I've been developing one such library called LEESA: Language for Embedded Query and Traversal <http://www.dre.vanderbilt.edu/LEESA>. LEESA has several capabilities: 1. Succinct and expressive XPath-like notation for writing object structure traversals 2. Supports child, parent, sibling, descendant, ancestor axes 3. Compile-time schema conformance checking 4. Supports GOF visitors and hierarchical visitors 5. Strategic Programming ... and more! Here are two quick examples comparing XPath and LEESA. More examples are available on the LEESA homepage. XPath expression: "/catalog/book/author/name/text()" LEESA expression: *std::vector<name> author_names = evaluate(root, catalog() >> book() >> author() >> name()); * XPath expression: "//name/text()" LEESA Expression: *std::vector<name> names = evaluate(root, catalog() >> DescendantsOf(catalog(), name())); * The above expressions are checked for schema-conformance at compile-time. LEESA builds these capabilities on top of existing XML data binding tools that generate C++ code from .xsd files. The general process of using LEESA is as follows: 1. Generate C++ classes using your favorite XML data binding tool 2. A python script that comes with LEESA adds a few functions in every generated C++ class. It generates a lot of typedefs and helper functions, which invoke tool generated code. This creates a bridge between LEESA and the code generated by the xml data binding tool. Currently it supports Code Synthesis's xsd and Universal Data Model (UDM) from Vanderbilt University as the underlying code generators. 3. The user includes LEESA.h in his/her C++ program (it is header-only), uses its programming model, compiles, and links with the tool generated code and libraries. So folks, please speak up if you are interested in having such a library in Boost. Thanks, Sumant.

1 0

[Bug Sprint] Status for Sunday, November 28th.
by Marshall Clow 28 Nov '10

28 Nov '10

There were 62 changes to the trac database yesterday. [ I'd like to say "62 tickets were changed", but some tickets were changed more than once. ] Activities on the trac system yesterday: viboes 28 tickets marshall 9 tickets troyer 6 tickets ktchan 6 tickets Others 13 tickets General information about the bug sprint is here: https://svn.boost.org/trac/boost/wiki/BugSprintNov2010 General information about how the Trac system works is here: https://svn.boost.org/trac/boost/wiki/TicketWorkflow Overall bug count: November 26: 946 November 27: 939 November 28: 930 If you're looking for something to do, here's a list of 100 bugs that were created in 2008 or before: <https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=re…> Top 10 components by ticket count: Component Tickets date_time 57 thread 53 Python 48 filesystem 41 build 40 asio 38 mpl 37 smart_ptr 37 program_options 28 uBLAS 28 Useful reports: https://svn.boost.org/trac/boost/report/1 -- full list of tickets https://svn.boost.org/trac/boost/report/18 -- ticket counts by owner https://svn.boost.org/trac/boost/report/19 -- ticket counts by component https://svn.boost.org/trac/boost/report/20 -- ticket counts by ticket type https://svn.boost.org/trac/boost/report/21 -- ticket counts by milestone

1 0

[bind] Patch for Ticket #4532 make_adaptable undocumented
by Daniel Trebbien 27 Nov '10

27 Nov '10

Attached is a patch that fixes Ticket #4532 make_adaptable undocumented <https://svn.boost.org/trac/boost/ticket/4532>. Daniel

2 2

[Bug Sprint] I'm looking at ticket #4791
by Marshall Clow 27 Nov '10

27 Nov '10

Unless someone objects.... -- Marshall

2 1

[python] warnings removal
by Vicente BOTET 27 Nov '10

27 Nov '10

Hi, with gcc-4.3.4 there is a warning * warning: type attributes ignored after type is already defined gcc.compile.c++ bin.v2/libs/python/build/gcc-4.3.4/release/threading-multi/numeric.o In file included from ./boost/python/object/make_instance.hpp:9, from ./boost/python/object/make_ptr_instance.hpp:8, from ./boost/python/to_python_indirect.hpp:11, from ./boost/python/converter/arg_to_python.hpp:10, from ./boost/python/call.hpp:15, from ./boost/python/object_core.hpp:14, from ./boost/python/object.hpp:9, from ./boost/python/tuple.hpp:10, from ./boost/python/numeric.hpp:10, from libs\python\src\numeric.cpp:6: ./boost/python/object/instance.hpp:14: warning: type attributes ignored after type is already defined This warning can be removed by adding a forward declaration file. See attached patch. * warning: deprecated conversion from string constant to â€˜char*â€™ ./boost/python/object/instance.hpp:14: warning: type attributes ignored after type is already defined libs\python\src\object\class.cpp: In function â€˜int boost::python::property_init(PyObject*, PyObject*, PyObject*)â€™: libs\python\src\object\class.cpp:79: warning: deprecated conversion from string constant to â€˜char*â€™ libs\python\src\object\class.cpp:79: warning: deprecated conversion from string constant to â€˜char*â€™ libs\python\src\object\class.cpp:79: warning: deprecated conversion from string constant to â€˜char*â€™ libs\python\src\object\class.cpp:79: warning: deprecated conversion from string constant to â€˜char*â€™ This warning can be removed with attached patch. Can these patches be include in trunk? Best, Vicente

2 1

[web] bad link for 1.45 release notes
by Vicente BOTET 27 Nov '10

27 Nov '10

Hi, The link in http://www.boost.org/community/review_schedule.html related to the Boost 1.45 Released point to the release notes of 1.44. Can this be corrected? Best, Vicente

2 1

[python] more warnings removal
by Vicente BOTET 27 Nov '10

27 Nov '10

Hi again, here there is other warning and the associated patches D:\boost\trunk\libs\python\src\converter\builtin_converters.cpp:369: warning: â€˜boost::python::converter::::py_unicode_as_string_unaryfuncâ€™ defined but not used Best, Vicente

1 0

[cygwin] warning "BOOST_CYGWIN" redefined
by Vicente BOTET 27 Nov '10

27 Nov '10

Hi, There is a warning in Boost.Config under CYGWIN that appears to much times as the config files is used a lot. gcc.compile.c++ bin.v2/libs/wave/build/gcc-4.3.4/release/link-static/threading-m ulti/wave_config_constant.o In file included from ./boost/config.hpp:53, from ./boost/wave/wave_config.hpp:16, from libs\wave\src\wave_config_constant.cpp:20: ./boost/config/platform/cygwin.hpp:10:1: warning: "BOOST_CYGWIN" redefined In file included from ./boost/config.hpp:35, from ./boost/wave/wave_config.hpp:16, from libs\wave\src\wave_config_constant.cpp:20: ./boost/config/compiler/gcc.hpp:96:1: warning: this is the location of the previ ous definition John, I have attached a patch. for the trunk. Could it be include? Best, Vicente

2 1

[python] still compile error using pyhton 3.x
by Christopher Lux 27 Nov '10

27 Nov '10

Hi, since 1.44 boost python does not compile anymore using python 3.x (after a GSOC project it worked fine with python 3.1). I reported this after the 1.44 release and i thought someone had fixed it. This is really sad to see this great library not working anymore. These are the errors generated: compile-c-c++ e:\devel\_ext\boost_out_64\out\boost\bin.v2\libs\python\build\msvc-10.0\debug\address-model-64\threading-multi\object\function_doc_signature.obj function_doc_signature.cpp E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C2065: 'PyInt_Type' : undeclared identifier E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C2065: 'PyInt_Type' : undeclared identifier E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(138) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C2065: 'PyInt_Type' : undeclared identifier E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C2065: 'PyInt_Type' : undeclared identifier E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C2039: 'PyInt_FromLong' : is not a member of '`global namespace'' E:\devel\boost_1_45_0\boost/python/converter/builtin_converters.hpp(144) : error C3861: 'PyInt_FromLong': identifier not found E:\devel\boost_1_45_0\boost/python/detail/caller.hpp(55) : warning C4244: 'return' : conversion from 'Py_ssize_t' to 'unsigned int', possible loss of data libs\python\src\object\function_doc_signature.cpp(287) : warning C4244: 'initializing' : conversion from 'boost::python::ssize_t' to 'int', possible loss of data libs\python\src\object\function_doc_signature.cpp(294) : warning C4244: '=' : conversion from 'boost::python::ssize_t' to 'int', possible loss of data libs\python\src\object\function_doc_signature.cpp(303) : warning C4244: '=' : conversion from 'boost::python::ssize_t' to 'int', possible loss of data

4 4

[1.45.0] PDF build of documentation available
by John Maddock 26 Nov '10

26 Nov '10

The PDF build of the documentation for Boost-1.45 is now available for download from https://sourceforge.net/projects/boost/files/boost-docs/1.45.0/ Enjoy, John Maddock.

1 0

[interprocess] why not use boost/system/error_code?
by Christian Holmquist 26 Nov '10

26 Nov '10

Hi, Is there any reason to have an own error code wrapper in boost::interprocess/errors.hpp, instead of using boost::system::error_code? Cheers, Christian

3 3

[guidelines] why template errors suck
by Eric Niebler 26 Nov '10

26 Nov '10

This is borderline self-promotion and I fretted posting this. But we a community of advanced C++ library developers and I'd really like feedback about these issues. And they really do involve Boost library development. If we could reach agreement about these techniques, we might want to integrate them into Boost's coding guidelines. http://www.reddit.com/r/programming/comments/diddg/expressive_c_why_templat… Comments? -- Eric Niebler BoostPro Computing http://www.boostpro.com

24 136

Bug-fix volunteers: risks, downsides?
by Jim Bell 26 Nov '10

26 Nov '10

To round out the discussion... What risks or downsides would there be to recruiting a little legion of bug-fix volunteers and turning them loose on the tickets and/or regression matrix?

10 23

[1.44][build] Improving support for VC10 and Adding support for Intel C++ 12
by Jeff Benshetler 26 Nov '10

26 Nov '10

I'm working through updating msvc.jam to better support VC10, primarily so that intel-win.jam works more cleanly for Intel C++ 12. It looks like the last substantial revision to msvc.jam was for VC8, although it still works well for VC9 and VC10. The changes I've made work well; my next post is to Intel about "internal error: 0_1374", which seems to be a catch-all. My overall goal is to better support the new target architectures and optimization features available in VC10 and Intel C++ 12. I'm new here, so I wanted to make sure that 1) I'm not duplicating work; 2) I'm following the appropriate procedure. BTW, I posted to the Boost Build list a couple days ago and there has been no traffic at all. Any guidance is appreciated.

2 1

[filesystem3] CP_ACP vs CP_THREAD_ACP
by Yechezkel Mett 25 Nov '10

25 Nov '10

Whilst moving from filesystem v2 to v3 on Windows I found that the library uses CP_THREAD_ACP to convert between narrow and wide filenames. This is wrong, as I will attempt to explain. Background: Windows uses a number of locales and language settings as described on the following page: http://msdn.microsoft.com/en-us/library/dd319088(v=VS.85).aspx The relevant ones are Language for non-Unicode programs (System Locale), Standards and Formats (User Locale) and Thread Locale. The System Locale defines which code page is used by the system for narrow chars, and is set by the user system-wide. The User Locale is for formatting numbers and sorting and is set by the user system-wide. The Thread Locale is also for formatting numbers and sorting, is per-thread, and defaults to the User Locale but can be changed by the program; however it is recommended in a number of places not to touch it (although the exact reasons seem vague, apparently it can have surprising effects). CP_ACP gives the System Locale code page. CP_THREAD_ACP gives the Thread Locale code page which is rather a strange item considering that the Thread Locale isn't meant for code pages at all! "ANSI" (ie narrow char) API functions (including CreateFileA) use the System Locale code page (CP_ACP). fopen (VC++9.0) just passes the filename through to the Windows API and therefore also uses CP_ACP. fstream (VC++9.0) uses mbstowcs_s, which uses the global C locale (not the global C++ locale). Narrow char windows use CP_ACP. boost.filesystem should therefore either use CP_ACP (to be consistent with the Windows API, fopen and the GUI) or the global C++ locale (to be consistent with fstream). (Using the global C locale seems a strange idea, but since setting the global C++ locale automatically sets the global C locale as well, that seems a good compromise.) Using CP_ACP gives something that "just works", it's almost certainly what is needed. Using the global C++ locale is perhaps theoretically correct; it can be set (by the user) to match CP_ACP as follows: std::locale::global(std::locale(str(boost::format(".%||") % GetACP()).c_str(), LC_CTYPE)); which is likely the correct thing for most programs anyway, and also allows the user to choose something different should that be necessary. (Unfortunately std::locale("") doesn't do the right thing - it takes the user locale for everything, including code page, and as explained above the user locale has nothing to do with code page.) In many (perhaps most) cases the user locale and system locale will be the same, but not always - for example I have the user locale set to English UK (for dates) but the system locale set to Hebrew (I need to be able to use Hebrew in non-Unicode programs). Yechezkel Mett

1 0

[config] compiler/gcc.hpp version 4.5 to update
by vicente.botet 25 Nov '10

25 Nov '10

Hi, in gcc.hpp the last know version is 4.4 // last known and checked version is 4.4 (Pre-release): #if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 4)) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" Is there any new features that should be updated for gcc-4.5? Even if gcc-4.6 has not been released yet it will be useful to update the file for this version also. In particular I'm interested in the consexpr feature. How can I help? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

3 11

[context] build error with -std=c++0x
by Charlls Quarra 25 Nov '10

25 Nov '10

Hi, i'm trying to get boost.context (from boost vault) to build with g++ 4.4.1 and 4.5.1 with -std=c++0x on both compilers i'm getting this error: In function `main': test.cpp:(.text+0x94): undefined reference to `boost::contexts::context::operator=(boost::contexts::context&&)' collect2: ld returned 1 exit status the test case is the following code: ------- test.cpp -------------- #include <boost/context.hpp> #include <iostream> using namespace std; void CallWrapper(void* p) { cout << " inside CallWrapper " << endl; }; int main() { boost::context ctx; boost::context current = boost::context::current(); ctx = boost::context::create(CallWrapper, current , 0 , boost::context::default_stacksize); cout << " after creating the context, before executing it " << endl; current.jump_to(ctx); cout << " after executing the context " << endl; }; ----------------------------------- i built the code with this command line: g++ -std=c++0x `pkg-config --cflags boost-1.43` test.cpp -o xtest `pkg-config --libs boost-context` -lboost_context -lboost_system when i remove -std=c++0x from the command line, the code compiles and runs fine Charles J. Quarra

4 4

[move] problem with msvc-10 (BOOST_MOVABLE_BUT_NOT_COPYABLE)
by Oliver Kowalke 25 Nov '10

25 Nov '10

-------- Original-Nachricht -------- Betreff: [move] problem with msvc-10 (BOOST_MOVABLE_BUT_NOT_COPYABLE) Datum: Wed, 24 Nov 2010 20:56:46 +0100 Von: Oliver Kowalke <oliver.kowalke(a)gmx.de> An: boost(a)lists.boost.org Hi, msvc-10 has some problems with boost.move. linker error: LNK2019: unresolved symbol "private __cdecl X::X(class X const&)" Example doc_file_descriptor.cpp (uses BOOST_MOVABLE_BUT_NOT_COPYABLE) does not compile too. g++-4.4.5 accepts the code. ? thx, Oliver #include <boost/move/move.hpp> #include <boost/shared_ptr.hpp> class X { private: BOOST_MOVABLE_BUT_NOT_COPYABLE( X); struct impl_t {}; boost::shared_ptr< impl_t > impl_; X( boost::shared_ptr< impl_t > const& impl); public: X(); static X create(); X( BOOST_RV_REF( X) other); X & operator=( BOOST_RV_REF( X) other); void swap( X & other); }; X::X() : impl_() {} X::X( boost::shared_ptr< impl_t > const& impl) : impl_( impl) {} X X::create() { boost::shared_ptr< impl_t > impl( new impl_t() ); return X( impl); } X::X( BOOST_RV_REF( X) other) : impl_() { impl_.swap( other.impl_); } X & X::operator=( BOOST_RV_REF( X) other) { if ( this != & other) { X tmp( other); swap( tmp); } return * this; } void X::swap( X & other) { impl_.swap( other.impl_); } int main(int argc, char * argv[]) { X x( X::create() ); return 0; }

3 3

[1.45.0] release note are insufficient
by Akira Takahashi 25 Nov '10

25 Nov '10

I have translated the release notes of 1.45.0 into Japanese now(but, don't .qbk). https://sites.google.com/site/boostjp/document/version/1_45_0 In the work, I found the missing library in release note: - Polygon : rev.66403 - Property Tree : #4340 - Serialization : rev.65965, rev.66030, rev.66107, rev.66123 - Thread : #4727, #4531, #2330 -- Akira Takahashi Blog : http://d.hatena.ne.jp/faith_and_brave/

13 14

[config] Variadic template macros in gcc header
by Edward Diener 24 Nov '10

24 Nov '10

Why is there two mutually exclusive macros indicating variadic template support for gcc ? There is the established BOOST_NO_VARIADIC_TEMPLATES which says that any compiler does not have variadic template support. Then I find that for gcc there is also BOOST_HAS_VARIADIC_TMPL which evidently says that the compiler does have variadic template support, and is in no other compiler header file than the gcc one. Since the two config macros are mutually exclusive in the gcc header file, why is there any need for BOOST_HAS_VARIADIC_TMPL ?

4 12

[build] bjam in boost/tools/build/v2/test doesn't work
by Jim Bell 22 Nov '10

22 Nov '10

Running bjam in boost/tools/build/v2/test doesn't (seem to) run build's regressions. Instead, I get: jamfile.jam:8: in modules.load rule project-root unknown in module Jamfile</F:/tmp/boost-MinGW-32/trunk/boost/t ools/build/v2/test>. F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:314: in load-jamfile F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:62: in load F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:168: in project.find F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2\build-system.jam:569: in load F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\..\kernel\modules.jam:283: in import F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\..\kernel\bootstrap.jam:14 2: in boost-build F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\boost-build.jam:14: in module scope If I run "python absolute_sources.py" (to pick that test as an example), I get very little (and it doesn't match regression test output): F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\TestCmd.py:60: Deprecation Warning: The popen2 module is deprecated. Use the subprocess module. import popen2 Am I close? I realize that build is a different animal. Are there instructions for running its tests in isolation? (Could those instructions be put in boost/tools/build/v2/index.html?) If you're reading this on the boost-build list, please CC me as I'm not subscribed. Thanks, -Jim PS: My apologies if I missed a response to this. I posted it last week on boost.

3 3

[accumulators] serialization support
by Zoran Angelov 22 Nov '10

22 Nov '10

Hi, Have anyone considered for boost.accumulators having a serialization support? It will be helpful for example in situations where data is being accumulated/sampled on long time intervals, and persistence of boost.accumulators objects is impossible. Something like this: boost/accumulators/statistics/count.hpp: . . . template<typename Sample, typename Tag> struct immediate_mean_impl : accumulator_base { // for boost::result_of typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type; template<typename Args> immediate_mean_impl(Args const &args) : mean(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value)) { } template<typename Args> void operator ()(Args const &args) { std::size_t cnt = count(args); this->mean = numeric::average( (this->mean * (cnt - 1)) + args[parameter::keyword<Tag>::get()] , cnt ); } result_type result(dont_care) const { return this->mean; } template <typename Archive> void serialize(Archive &ar, const unsigned int version) { ar & BOOST_SERIALIZATION_NVP(mean); } private: result_type mean; }; . . . The problem is that members, storing the state are private. Thanks

2 2

[1.45][signals2] Can't build PDF docs?
by John Maddock 21 Nov '10

21 Nov '10

I'm trying to build the signals2 docs for the PDF doc distribution, but I'm failing with: warning: failed to load external entity "hello_world_def_code_snippet.xml" tutorial.xml:50: element include: XInclude error : could not load hello_world_def_code_snippet.xml, and no fallback was found warning: failed to load external entity "hello_world_single_code_snippet.xml" tutorial.xml:52: element include: XInclude error : could not load hello_world_single_code_snippet.xml, and no fallback was found warning: failed to load external entity "hello_def_code_snippet.xml" tutorial.xml:63: element include: XInclude error : could not load hello_def_code_snippet.xml, and no fallback was found etc... I can see that process_snippets.exe is being invoked, but I can't find the output xml files anywhere. This occurs if I either build from within the doc/pdf directory, or the libs/signals2/doc directory. Any ideas? Thanks, John.

3 6

[1.45] Beta version of PDF docs available.
by John Maddock 21 Nov '10

21 Nov '10

There's a beta build of the PDF docs for 1.45 here: http://sourceforge.net/projects/boost/files/boost-docs/1.45.0/boost_1_45_pd… If library authors could check for the usual snafu's, and I'll build the final versions in a few days. Regards, John.

3 2

[Guild] Recruiting & Instructions, rough first draft
by Jim Bell 20 Nov '10

20 Nov '10

Here's some writing I threw down a little while ago. Please comment, here or privately. Copy my text for reference. It's on my website partly because I've done some formatting (emphasizing), as you'll see. It's rough, and lacks some crucial detail. http://jc-bell.com/contributions/boost-guild/boost-guild-recruit http://jc-bell.com/contributions/boost-guild/boost-ticket-handling http://jc-bell.com/contributions/boost-guild/boost-regression-troubleshooti… Cheers! -Jim

4 6

Boost 1.45.0 Release Notice
by Beman Dawes 20 Nov '10

20 Nov '10

Release 1.45.0 of the Boost C++ Libraries is now available. These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. This release contains numerous enhancements and bug fixes for existing libraries. For details, see http://www.boost.org/users/news/version_1_45_0 The release can be downloaded directly from SourceForge. See http://sourceforge.net/projects/boost/files/boost/1.45.0/ To install this release on your system, see http://www.boost.org/doc/libs/release/more/getting_started/index.html Thanks, --The Boost release team Beman Dawes Daniel James Eric Niebler Rene Rivera Vladimir Prus

1 0

[1.45.0] Release candidates available
by Beman Dawes 19 Nov '10

19 Nov '10

See http://boost.cowic.de/rc/ Please download the file for your favorite platform, try a build, and let us know if it works OK. We like some independent confirmation before pushing the files up to SourceForge. Thanks, --Beman

13 20

The cpp-netlib Release 0.8 is Out Now!
by Dean Michael Berris 19 Nov '10

19 Nov '10

Hi Everyone, advanced apologies for the cross-post. To those interested and watching the cpp-netlib project's progress, this afternoon Philippine time I just packaged and released the latest installment of the cpp-netlib project. Release 0.8 features: * An asynchronous HTTP server template, supporting asynchronous handler invocation and asynchronous writing to the established HTTP connection on the handler side. An example of one use for this is included in the library which implements a simple static web server, benchmarked with Apache AB on a dual core Intel Core 2 CPU with 2GB RAM to be able to serve a 10kb file at 4700 requests per second on 64-bit Linux 2.6.36. You can find out more about the example here: http://goo.gl/5mVuY * More in-depth documentation covering the HTTP Client and Server APIs, now hosted online as well. Read the documentation at http://cpp-netlib.github.com/0.8/ * A simple thread pool implementation that uses Boost.Asio underneath, with a simple API for posting nullary function objects as tasks. The number of threads to run is configurable as a constructor parameter -- this is especially required by the asynchronous HTTP server template, where handlers are queued to be executed. The library is released under the Boost Software License, and is being developed for future submission to the Boost C++ Library. You can download the latest and previous releases from http://github.com/cpp-netlib/cpp-netlib/downloads. Have a great day everyone and I look forward to your very valuable feedback! -- Dean Michael Berris deanberris.com

1 0

Boost bug sprint?
by Marshall Clow 19 Nov '10

19 Nov '10

Since we're now at November 13th, and I originally proposed starting the bug sprint "after the 1.45" release, and "On November 15th", I think that something's gotta give. So, I'm proposing that we start the bug sprint on Saturday, November 27th, and run through Sunday, December 5th (9 days, two weekends, one work week). That way people who work on boost as part of their day jobs will have a full week to participate, while those who do "nights and weekends" will have plenty of time as well. What does everyone think? -- Marshall

12 26

LLVM license compatibility with BSL
by vicente.botet 19 Nov '10

19 Nov '10

Hi, I have found quite useful to adapt the test for llvm/libc++ ratio/chrono to test Boost.Ratio and Boost.Chrono. But Anthony has signaled me that maybe there is a compatibility problem with the license included in these files. //===----------------------------------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// Is the LLVM License (http://llvm.org/docs/DeveloperPolicy.html#license) compatible with the Boost Software License? Can we include files with this comment on a Boost library? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

11 22

What's so cool about Boost.MPI?
by David Abrahams 18 Nov '10

18 Nov '10

Just wanted to call some attention to this article I wrote about Boost.MPI: http://daveabrahams.com/2010/09/03/whats-so-cool-about-boost-mpi/ I think it might be useful to link that from the Boost.MPI docs, too. -- Dave Abrahams BoostPro Computing http://www.boostpro.com

2 2

[Probing interest] -- automatization of writing predicates.
by Petr Pilař 18 Nov '10

18 Nov '10

Hi folks, I often find myself in a situation where I need a simple comparison predicate for filtering, look-up, etc. Writing such predicates can get tedious over time and adds unnecessary "bloat", especially when you use the predicate only once. For that reason I have automated this process and I'm interested whether others might find it useful as well. Usage example: auto_predicate(&ClassName::getter, compareWithMe) -- this returns functor which compares the returned value with compareWithMe using == operator. auto_predicate(&ClassName::getter, compareWithMe, comparator) -- this returns functor which compares the returned value with compareWithMe using the given comparator. (Note: getter return type does not have to match compareWithMe type have you supplied comparator with proper signature.) Best regards, Petr Pilař.

3 3

Boost.FileSystem dependency on Boost.System
by Matthew Gwynne 18 Nov '10

18 Nov '10

Hi, It seems when compiling anything using Boost.FileSystem that the Boost.System library is also linked. Is this always the case? I can't see any clear documentation of this on the Boost.FileSystem page. If this is the case, is there a nice list of all such dependencies somewhere, as this is currently causing us certain issues? Thanks! Matthew Gwynne http://cs.swan.ac.uk/~csmg/

1 0

for_each abstraction
by Karsten Ahnert 18 Nov '10

18 Nov '10

Hi, I need something like an abstraction layer for iterations over some range. Consider for example the following three statements, which all do the same, but the loop inside each for_each is different: // thrust is an STL-like interface for CUDA [1] thrust::device_vector< double > a1( 3 ); thrust::for_each( a1.begin() , a1.end() , op() ); std::vector< double > a2( 3 ); __gnu_parallel::for_each( a2.begin() , a2.end() , op() ); std::vector< double > a3( 3 ); std::for_each( a3.begin() , a3.end() , op() ); //maybe even fusion::vector< double , double , double > a4; fusion::for_each( a4 , op() ); Is there a way or some part of a boost-library which handles the above three statements in a unique manner? I want to write algorithms which are independent of the specific for_each implementation. Best regards, Karsten [1] http://code.google.com/p/thrust/

5 13

[config] macro for unified initialization syntax?
by Eric Niebler 17 Nov '10

17 Nov '10

Is there a config macro for the presence/absence of C++0x uniform initialization syntax? http://en.wikipedia.org/wiki/C%2B%2B0x#Uniform_initialization If not, I suggest BOOST_NO_UNIFORM_INITIALIZATION_SYNTAX. A quick test shows that gcc-4.5 in 0x mode has it. -- Eric Niebler BoostPro Computing http://www.boostpro.com

2 2

[1.45] Beta 1 release candidates
by Beman Dawes 17 Nov '10

17 Nov '10

[1.45] Beta 1 release candidates are available at http://boost.cowic.de/rc/ As usual, please report success or failure doing builds. We like to get reports of successful builds on several varied platforms before the files are pushed out to SourceForge and the formal announcement made. Thanks, --Beman

8 14

Interest in B-tree library for Boost?
by Beman Dawes 17 Nov '10

17 Nov '10

A Boost B-tree library would provide disk-based associative containers that scale all the way from really, really, small to really, really, large. B-trees perform well on hardware ranging from ancient floppy disk drives all the way up to humongous disk arrays. They are the technology behind most high-performance disk file systems and databases. If you don't know what a B-tree is, or think that "B-tree" is an abbreviation for "Binary tree", you might want to read the Wikipedia B-Tree article: http://en.wikipedia.org/wiki/B-tree. Knuth and other computer science texts also supply descriptions. See http://mysite.verizon.net/beman/btree/index.html for a more complete description of the proposed library. A preliminary implementation is available. Download http://mysite.verizon.net/beman/btree/btree-preview-1.zip, and unpack into a current Boost distribution. A few existing Jamfiles will be overwritten. The only compilers tested and working so far are VC++ 10 and GCC/MinGW 4.5. You can view the library online at http://github.com/Beman/Boost-Btree There is no detailed documentation yet, but if you know how to use std::map and other standard library associative containers, you already know most of what you need to know. Critical differences are documented in the Library Characteristics section of the index.html page referenced above. Initial timing tests have been very encouraging. The time test compares the btree_map implementation to std::map. As expected, a btree_map is many times slower than a std::map, given a cold operating system file cache and constraining the btree_map's caching to a minimum. But at the other extreme, when the O/S file cache is warm and the btree_map's cache is as large as the file, the btree_map is very similar in speed to std::map.The btree library's code is still very new, so timings and everything else may be subject to lots of revision. Any interest? --Beman

14 37

[build] bjam in boost/tools/build/v2/test doesn't work
by Jim Bell 17 Nov '10

17 Nov '10

Running bjam in boost/tools/build/v2/test doesn't (seem to) run build's regressions. Instead, I get: jamfile.jam:8: in modules.load rule project-root unknown in module Jamfile</F:/tmp/boost-MinGW-32/trunk/boost/t ools/build/v2/test>. F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:314: in load- jamfile F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:62: in load F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2/build\project.jam:168: in proje ct.find F:/tmp/boost-MinGW-32/trunk/boost/tools/build/v2\build-system.jam:569: in load F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\..\kernel\modules.jam:283: in import F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\..\kernel\bootstrap.jam:14 2: in boost-build F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\boost-build.jam:14: in mod ule scope If I run "python absolute_sources.py" (to pick that test as an example), I get very little (and it doesn't match regression test output): F:\tmp\boost-MinGW-32\trunk\boost\tools\build\v2\test\TestCmd.py:60: Deprecation Warning: The popen2 module is deprecated. Use the subprocess module. import popen2 Am I close? I realize that build is a different animal. Are there instructions for running its tests in isolation? (Could those instructions be put in boost/tools/build/v2/index.html?)

1 0

[python] [1.45] select_holder test failing
by Eric Niebler 17 Nov '10

17 Nov '10

Dave, The python "select_holder" test is failing across a large number of platforms on the release branch including all clang and gcc compilers. Can you please look into this prior to 1.45? Thanks, -- Eric Niebler BoostPro Computing http://www.boostpro.com

5 8

Boost.Build -q fix for 1.45
by Vladimir Prus 16 Nov '10

16 Nov '10

On IRC, Philipp Reh reported that 1.45 beta will fail if Boost.Build is invoked with -q, and any configuration test fails. The reason is that while Steven fixed this on trunk some time ago, I failed to merge to release branch. Since this bug means that Boost will outright not build in some cases, and since the fix is not really new, I think it should be checked in to release branch even at this point. The proposed diff is this: http://codepad.org/eoeawRoG Any objections before I go ahead? - Volodya

3 2

[clang] Using a stable clang for testing
by Daniel James 16 Nov '10

16 Nov '10

Hi, I posted about this on the testing list, but got no response, so I thought I'd try again here. To properly support clang, we need at least one release tester to use the stable clang release. According to config_info (which is at libs/config/test/config_info.cpp) the stable version is: "Clang version 2.8 (branches/release_28)", but the release tests are using "Clang version 2.8 (trunk 111264)" and "Clang version 2.9 (trunk 119008)". Would it be possible for someone to use the released version? Daniel

2 1

[netlib] 0.8-beta now available!
by Dean Michael Berris 16 Nov '10

16 Nov '10

Hi Everyone, advanced apologies for cross-posting. I've just tagged and uploaded archives of the cpp-netlib 0.8-beta which features: * An asynchronous server template, allowing for server-side streaming of data, asynchronous writing and reading facilities for server-side handlers, and a thread pool implementation that's temporarily using Boost.Asio's io_service for application-specific asynchronous handlers to run from. * A `ready(...)` wrapper to check for whether an asynchronous client's response is ready. The documentation has also been updated to feature a brand-new reference manual detailing the implementation, caveats, and public API of the HTTP client and server templates. You can go ahead and download the 0.8-beta and report issues you find either directly to me or through the mailing lists (Boost.User, Boost.Devel, and the cpp-netlib developers mailing lists). The target release for 0.8 will be this Friday, November 19, 2010. As usual, you can download the 0.8-beta package from GitHub at: https://github.com/cpp-netlib/cpp-netlib/downloads You can also check out the documentation for 0.8-beta at: http://cpp-netlib.github.com/0.8-beta Thanks everyone and I look forward to most appreciated feedback! -- Dean Michael Berris deanberris.com

5 14

[parameter] Boost.Parameter Constructors in Template Classes
by Dean Michael Berris 16 Nov '10

16 Nov '10

Hi Everyone, I'm not sure whether this is more appropriate for the users list or the developers list so I sent the email to both. I'm using Boost's SVN Trunk r66609 and I tried to compile the (attached) file to follow the pattern described by the Boost.Parameter tutorial (http://www.boost.org/doc/libs/1_44_0/libs/parameter/doc/html/index.html#par…) but unfortunately I get an error deep in the preprocessor code that Boost.Parameter uses. What I'm trying to do is to make a template class support parameterized constructors, and only have optional parameters and no required ones. The idea is: template <class Tag> struct base; template <class Tag> struct derived : base<Tag> { BOOST_PARAMETER_CONSTRUCTOR(...); }; Has anybody been able to make this work? Thanks and I definitely hope to hear from you soon. PS. I am also going to file this as a bug in Boost.Parameter so that it doesn't get lost in the mailing list churn. ;) -- Dean Michael Berris deanberris.com

2 3

[Review] Formal Review of Proposed Boost.Chrono Library LAST DAY TODAY
by Anthony Williams 15 Nov '10

15 Nov '10

Hi everyone, The review of Vicente Botet's Chrono library is underway; TODAY IS THE LAST DAY. If you haven't already submitted a review, please do so today. What is it? ======== Boost.Chrono aims to implement the new time facilities in C++0x, as proposed in N2661 - A Foundation to Sleep On (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm) That document provides background and motivation for key design decisions and is the source of a good deal of information in this documentation. See the current C++0x working draft at http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf for details of what was accepted. The Boost.Chrono library provides: * A means to represent time durations: managed by the generic duration class . Examples of time durations include days, minutes, seconds and nanoseconds, which can be represented with a fixed number of clock ticks per unit. All of these units of time duration are united with a generic interface by the duration facility. * A type for representing points in time: time_point. A time_point represents an epoch plus or minus a duration. The library leaves epochs unspecified. A time_point is associated with a clock. * Several clocks, some of which may not be available on a particular platform: system_clock, monotonic_clock and high_resolution_clock. A clock is a pairing of a time_point and duration, and a function which returns a time_point representing now. * To make the timing facilities more generally useful, Boost.Chrono provides a number of additional clocks that are thin wrappers around the operating system's time APIs, thereby allowing the extraction of read (wall clock) time, user CPU time, system CPU time, - process_real_cpu_clock, captures real (wall clock) CPU times. - process_user_cpu_clock, captures user-CPU times. - process_system_cpu_clock, captures system-CPU times. - A tuple-like class __process_cpuclock_, that captures real, user-CPU, and system-CPU times together. - A thread_clock thread monotonic clock, when supported by a platform. * Boost.Chrono also includes typeof registration for duration and time_point to permit using emulated auto with C++03 compilers. * Boost.Chrono also provides I/O for duration and time_point. It builds on <boost/ratio/ratio_io.hpp> to provide readable and flexible formatting and parsing for types in <boost/chrono.hpp> (subject to Vicente rewriting the parsing code under the BSL). The duration unit names can be customized through a new facet: duration_punct. Getting the library ============= The latest version of this library may be downloaded from vault: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=chrono… SVN: http://svn.boost.org/svn/boost/sandbox/chrono Boost.Chrono depends on Boost.Ratio http://www.boostpro.com/vault/index.php?action=downloadfile&filename=ratio.… and optionaly Boost.System Header Only http://www.boostpro.com/vault/index.php?action=downloadfile&filename=system…. and the docs may be viewed here HTML: http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/html/index.ht… PDF: http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/chrono.pdf You can get all these information also (which should avoid some long links) from http://svn.boost.org/trac/boost/wiki/LibrariesUnderConstruction#Boost.Chrono Writing a review ================ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager. Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick - reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Anthony Review Manager for the proposed Boost.Chrono library -- Author of C++ Concurrency in Action http://www.stdthread.co.uk/book/ just::thread C++0x thread library http://www.stdthread.co.uk Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk 15 Carrallack Mews, St Just, Cornwall, TR19 7UL, UK. Company No. 5478976

5 6

[function] function wrapping with no exception safety guarantee
by Daniel Walker 15 Nov '10

15 Nov '10

Hi all, A few weeks ago, there was a request to remove boost::function's dependency on boost::throw_exception when the user ensures that boost::function is always initialized before attempting a call. https://svn.boost.org/trac/boost/ticket/4646 Providing an alternative invocation method in addition to the call operator is an unattractive solution for many reasons; e.g. boost::function would be less function-like syntacticly. Instead, why not provide an alternative function wrapper with no exception safety guarantee and no dependency on boost::throw_exception? Thanks to Boost.Function's implementation design, which uses preprocessor metaprogramming to generate many function wrappers with different arities, it is simple to generate a function wrapper with no exception safety guarantee. I have submitted a feature request with a patch that implements boost::unsafe_function -- a function wrapper with no exception safety guarantee -- along with tests and updated documentation. https://svn.boost.org/trac/boost/ticket/4720 unsafe_function's API and semantics are identical to boost::function except that the behavior of operator() is undefined when uninitialized. Also, swap, constructor and assignment operators have been added to allow an unsafe_function to wrap the target of a boost::function and vice versa. unsafe_function is primarily useful in certain environments in which exceptions and/or compiler optimizations are unavailable, such as some embedded systems. On contemporary PC hardware, unsafe_function typically would not have an advantage over boost::function. For example, with object code generated by gcc -O2, I could only detect a ~1% difference between the two in terms of runtime costs using a simple benchmark; i.e. less than a nanosecond. However, with -O1, unsafe_function costs ~15% less than boost::function due to the lack of overhead from the strong exception safety guarantee. Thoughts? Daniel Walker

19 127

[1.45][thread] TSS showstopper?
by John Maddock 15 Nov '10

15 Nov '10

The recent changes to Boost.Thread in both Trunk and Release branches have broken one of the regex tests: testing.capture-output ..\..\..\bin.v2\libs\regex\test\regex_regress_threaded.test\msvc-10.0\debug\asynch-exceptions-on\threading-multi\regex_regress_threaded.run ====== BEGIN OUTPUT ====== TSS Initialisation failed with message: boost::thread_resource_error **** error return code: -1 ******** errors detected; see standard output for details ******** EXIT STATUS: 1 ====== END OUTPUT ====== I assume it's quite likely that if this effects the regex lib, then it will equally impact on user code that uses thread_specific_pointer? Regards, John.

3 7

Re: [boost] [Boost-commit] svn:boost r66577 - trunk/libs/numeric/ublas/test
by Jürgen Hunold 15 Nov '10

15 Nov '10

Hi David, This commit On Sunday, 14. November 2010 20:34:07 david.bellot(a)gmail.com wrote: > Author: david.bellot > Date: 2010-11-14 14:34:04 EST (Sun, 14 Nov 2010) > New Revision: 66577 > URL: http://svn.boost.org/trac/boost/changeset/66577 > > Log: > update jamfile > > Text files modified: > trunk/libs/numeric/ublas/test/Jamfile.v2 | 2 ++ > 1 files changed, 2 insertions(+), 0 deletions(-) > > Modified: trunk/libs/numeric/ublas/test/Jamfile.v2 > ============================================================================ --- trunk/libs/numeric/ublas/test/Jamfile.v2 (original) > +++ trunk/libs/numeric/ublas/test/Jamfile.v2 2010-11-14 14:34:04 EST > (Sun, 14 Nov 2010) @@ -134,4 +134,6 @@ > ] > [ run test_assignment.cpp > ] > + [ test_boost_ublas_size_0.cpp > + ] > ; just broke the test. First, the call is totally wrong, should read "run test_boost-..." ../libs/numeric/ublas/test/Jamfile.v2:138: in modules.load rule test_boost_ublas_size_0.cpp unknown in module Jamfile</home/hunold/src/devel/boost/libs/numeric/ublas/test>. Second,test_boost_ublas_size_0.cpp is missing from svn. error: Unable to find file or target named error: 'test_boost_ublas_size_0.cpp' error: referred from project at error: '.' Please add at least the missing file. Yours, Jürgen -- * Dipl.-Math. Jürgen Hunold ! Ingenieurgesellschaft für * voice: ++49 511 262926 57 ! Verkehrs- und Eisenbahnwesen mbH * fax : ++49 511 262926 99 ! Lister Straße 15 * juergen.hunold(a)ivembh.de ! www.ivembh.de * * Geschäftsführer: ! Sitz des Unternehmens: Hannover * Prof. Dr.-Ing. Thomas Siefer ! Amtsgericht Hannover, HRB 56965 * PD Dr.-Ing. Alfons Radtke !

1 0

[1.45] Where are we in the release process?
by John Maddock 14 Nov '10

14 Nov '10

I'm asking because someone's just assigned a Boost.Interval issue to me: https://svn.boost.org/trac/boost/ticket/4799#comment:1 Seems like there is a trivial fix in Trunk, but as the library appears not to have been maintained for while, it looks like none of the patches that some folks have applied to Trunk have been merged to release :-( On a related note, I believe there are quite a few old and unmerged changes to the Utility lib as well. We really need to figure out a better way of dealing with this... John.

6 13

Minimizing Dependencies within Generic Classes for Faster and Smaller Programs
by vicente.botet 14 Nov '10

14 Nov '10

Hi, I have found this paper "Minimizing Dependencies within Generic Classes for Faster and Smaller Programs" http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2911.pdf quite iteresting. The gain in performances and reduced space could be considerable. I was wondering if Boost should not take this as a guideline and whether the Boost authors would check his libraries to see if this technique could improve its performances, in particular for all the container and the the forthcomming Boost.Container libraries. I would be interested in knowing if this has been adopted for C==0x containers. Good reading, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

10 18

Standard stream from C fopen()
by Claude 14 Nov '10

14 Nov '10

Hi! I Use this code for make a standard stream from a C fopen() FILE* : FILE *fd = fopen("Prova", "w"); if (fd) { // io::stream_buffer<io::file_descriptor_source> fpstream (fileno(fd)); //std::istream in (&fpstream); istream in = boost::iostreams::file_descriptor(fileno(fd)); } But I obtain an error (G++ on Linux Ubuntu): [...] error: conversion from ‘boost::iostreams::file_descriptor’ to non-scalar type ‘std::istream’ requested| [...] error: call of overloaded ‘path(const int&)’ is ambiguous| [...] Why? What is the correct method? -- View this message in context: http://boost.2283326.n4.nabble.com/Standard-stream-from-C-fopen-tp3040002p3… Sent from the Boost - Dev mailing list archive at Nabble.com.

4 8

[1.45.0] Permission to merge trunk to release for Boost.Optional
by Fernando Cacciola 13 Nov '10

13 Nov '10

Hi, As reported by Eric Niebler, the release brunch did not had the swap member that existed in the trunk for a long time. I just merged it locally and run the tests on the release branch. Can I commit the changes? P.S: The test suite changed as well due to the different swap. P.S.2: I've also been reported on a couple of minor documentation issues, so I've fixed this on both the trunk and the release branch. P.S.3: Going over all the differences I've found a trivial change in the testsuite for value_initialized: The trunk version uses the lightweight "minimal" test tools instead of the full test tools. I've merged this one as well. Can I commit these changes to the release branch? --- Fernando Cacciola SciSoft Consulting, Founder http://www.scisoft-consulting.com

6 9

[FunctionTypes] Removing the ClassTransform when invoking parameter_types
by Edward Diener 12 Nov '10

12 Nov '10

When invoking boost::function_types::parameter_types with a member function pointer as the first template parameter, what do I susbstitute as the second template parameter so that no transform is done ?

2 1

[exception] [1.44] you own a showstopper
by Eric Niebler 12 Nov '10

12 Nov '10

Emil, The following bug in exception is marked as a Showstopper for the 1.44 release. What are your plans for it? If you're planning on fixing it, can you do so soon? If you feel it is not a showstopper, can you set its priority appropriately? https://svn.boost.org/trac/boost/ticket/4768 Thanks, -- Eric Niebler BoostPro Computing http://www.boostpro.com

3 6

Type traits extension & Bitfield reviews
by Joel Falcou 12 Nov '10

12 Nov '10

I've just seen these libraries hanging out in the review queue for quite some time now. Considering their potential usefulness adn my personnal interest, I consider stepping up as a review manager for these. What's the formal sequence to follow to apply for such a task ?

7 10

[inspect] added new check for C-style assert macro (was: [property_tree][showstopper][1.45] missing include in string_path.hpp)
by Eric Niebler 12 Nov '10

12 Nov '10

On 11/11/2010 3:49 PM, Sebastian Redl wrote: > On 11.11.2010, at 21:38, Eric Niebler wrote: >> If BOOST_ASSERT is *always* to be preferred over C's assert macro, >> then we should probably add that to the inspection report, right? > > That would probably a good idea. I just modified the inspect tool to check for the presence of C-style assert in Boost code. Everybody should be using BOOST_ASSERT. (Right?) Here's the result of running the new check over Boost trunk: http://pastebin.com/NttTw3BJ Beman, the inspection report looks like it was last run in June. What's up? http://boost.cowic.de/rc/inspect-trunk.html -- Eric Niebler BoostPro Computing http://www.boostpro.com

4 11

[1.45][filesystem/io] Streaming operator
by Chard 12 Nov '10

12 Nov '10

The filesystem path streaming operator (>>) has a bug in 1.44, documented here: https://svn.boost.org/trac/boost/ticket/4716 A patch has been provided, and has been implemented on the trunk, detailed here: http://lists.boost.org/boost-commit/2010/08/27576.php Any chance of this being merged to the release branch for 1.45? [.../boost/io/detail/quoted_manip.hpp] --

1 0

Re: [boost] [Boost-users] What's so cool about Boost.MPI?
by Matthias Troyer 12 Nov '10

12 Nov '10

On 5 Nov 2010, at 20:04, Riccardo Murri wrote: > On Fri, Nov 5, 2010 at 3:51 PM, Peter Foelsche <foelsche(a)sbcglobal.net> wrote: >> Can somebody explain to me, what is so great about mpi or boost/mpi? > > Daunting task, but I'll give it a try :-) > > MPI is a library interface[1] to ease some common communication > patterns in scientific/HPC software. In particular, MPI provides > library functions for: > > 1. Reliable delivery of messages between two concurrent processes; > there are functions for both synchronous and asynchronous > communication. > > 2. Collective communication of the running processes: e.g., one > process broadcasting a message to all others; all processes > broadcasting to all; scattering a large array to all running > processes, etc. > > 3. "Remote shared memory": a process can expose a memory buffer that > all others can directly read/write. > > 4. Parallel I/O, where many processes access (possibly interleaved) > portions of a file independently. > > Despite being non-trivial features to implement on top of a standard > TCP socket interface, MPI implementations are mostly into performance: > they can usually take advantage of special hardware (e.g., Infiniband > or Myrinet interconnects) and use the native protocols (instead of > TCP/IP) to provide faster communication speed. > > A "message" in usual socket programming is just a flat array of bytes. > A "message" in MPI is a (potentially non-contiguous portion) of a C or > FORTRAN data structure; MPI can handle C structures and > multi-dimensional C-style arrays, and multi-dimensional arrays of C > structures (containing multi-dimensional arrays, etc.). However, > since MPI is implemented as a library, you have to tdescribe to MPI > the in-memory layout of the data structures you want to send as a > message; thus "duplicating" work that is done by the compiler. You > can imagine that this quickly gets tedious and unwieldy once you start > having non-trivial data structures, possibly with members of unknown > length (e.g., a list). > > This is where Boost.MPI comes to the rescue: if you can provide > Boost.Serialization support for your classes, you can send them as MPI > messages with no extra effort: no need for lengthy calls to > MPI_Type_create_struct() etc. And it does this with minimal or even > no overhead! (Plus you also get a nice C++ interface to MPI > functionality, whereas the MPI C calls are quite low-level.) > > > .. [1] MPI proper is a specification; there are several > implementations of the spec (e.g., OpenMPI, MPICH, MVAPICH, plus > many vendor/proprietary one), but they are all compatible at the > source level. > > Best regards, > Riccardo Nice summary! Matthias

5 8

[1.45.0] Beta 1 available from SourceForge
by Beman Dawes 11 Nov '10

11 Nov '10

Boost release1.45.0 beta 1 is now available from SourceForge. For those who downloaded release candidate 1, note that beta 1 was build from a slightly later release candidate. See http://sourceforge.net/projects/boost/files/ This release contains numerous enhancements and bug fixes for existing libraries. For details of what's in the release, see http://beta.boost.org/users/news/version_1_45_0. Note that the links to files on this web page are for the final release - use the SourceForge link above to get the beta files. Please download the beta, give it a try, and report any problems you encounter. There are still a few serious bugs outstanding, and we will be working on clearing those before the final release. Thanks, -- The Boost Release Team

7 9

Re: [boost] [serialization][thread] possible regressions?
by Eric Niebler 11 Nov '10

11 Nov '10

On 11/11/2010 1:41 PM, Robert Ramey wrote: > Anthony Williams wrote: >> Eric Niebler <eric(a)boostpro.com> writes: >> >>> I don't know whether this is a serialization issue or a thread issue. >>> Robert, Anthony, can you two weigh in? >> >> Looks like a serialization problem to me. > > I would agree - but its hard to reproduce from here. I don't see this as > quick fix - it would require some time and help from the person who can > actually reproduce it. Thanks, Robert. This is now https://svn.boost.org/trac/boost/ticket/4842 Ruediger, anything you can do to help Robert with this one would be much appreciated. -- Eric Niebler BoostPro Computing http://www.boostpro.com

1 0

Problem with boost deserialization.
by Esteban RG 11 Nov '10

11 Nov '10

Hi, I need serialization in a project of mine. I have reduced my options to boost and ProtocolBuffer, but in order to be able to decide which one to use, I am trying to build a timing test for serialization and deserialization. Let me explain a little about my setup: a) Platform: - windows 7, 64bit version - visual studio 2008 express edition x32 b) Additional library: - ACE library for High resolution timer. The code (an explanations) that I have used to implement the comparison is at follows: I build a class with four different lists of boost/serialization/list like documentation states: std::list<unsigned int> &lint_; std::list<ACE_INT64> &llong_; std::list<float> &lfloat_; std::list<std::string> &lstring_; The test is increasing the size of every list simultaneously. Then it gets serializated and deserializated and finally I get the time results for this process. However there is one issue: Serialization always works, but deserialization fails during execution time whenever the lists are bigger than 10 elements, throws a exception "input stream error" into boost/serialization/throw_exception.hpp as seen with the debugger in the variable/const std::exception const &e (boost library) Visual studio shows this message: Unhandled exception at 0x765cb727 in prTestBoostSerialization2.exe: Microsoft C++ exception: boost::archive::archive_exception at memory location 0x003fc564.. my class definition is: #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/list.hpp> //#include <boost/serialization/version.hpp> //#include <boost/serialization/split_member.hpp> #include <iostream> #include <list> #include <string> class BoostSerializationClass { public: // Not required because al member are public // friend class boost::serialization::access; BoostSerializationClass(std::list<unsigned int> &lint , std::list<float> &lfloat , std::list<ACE_INT64> &llong , std::list<std::string> &lstring) : lint_(lint), lfloat_(lfloat), llong_(llong), lstring_(lstring) { //std::cout << std::endl << " max size " << lint_.max_size(); //std::cout << std::endl << " " << llong_.max_size(); //std::cout << std::endl << " " << lfloat_.max_size(); //std::cout << std::endl << " " << lstring_.max_size(); } std::list<unsigned int> &lint_; std::list<ACE_INT64> &llong_; std::list<float> &lfloat_; std::list<std::string> &lstring_; }; namespace boost { namespace serialization { template<class Archive> void serialize(Archive &ar, BoostSerializationClass &c , const unsigned int version){ ar & c.lint_; ar & c.llong_; ar & c.lfloat_; ar & c.lstring_; } } } ----------------------- And main function is: #include <iostream> #include <fstream> //#include <cstdlib> #include <ace/OS.h> #include <ace/Time_Value.h> #include <ace/High_Res_Timer.h> // high resolution timer // include for BOOST #include "../prTestProtocolBuffers/BoostSerializationClass.h" #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> //#include <list> <- dont include this use boost/serialization/list #include <boost/serialization/list.hpp> void gen_random_string(std::string &s, const int len); int ACE_TMAIN(int argc, ACE_TCHAR* argv[]){ //int lengthList = 5; //int lengthList = 10; int lengthList = 15; //int lengthList = 50; // int lengthList = 100; // int lengthList = 1000; std::list<unsigned int> listInteger,listInteger2; std::list<float> listFloat,listFloat2; std::list<ACE_INT64> listLongs,listLongs2; std::list<std::string> listString,listString2; int rint = 0; float rfloat = 0.f; ACE_INT64 rint64 = 0; std::string rstring = ""; std::cout << std::endl << "Begin random generate message. Please be patient."; // Generate random fields for messages for (int i=0 ; i<lengthList ; i++){ listInteger.push_back( rand() ); listFloat.push_back( (float)rand()/(float)RAND_MAX ); listLongs.push_back( rand()*rand()*rand() ); gen_random_string(rstring, lengthList); listString.push_back( rstring ); } // BOOST SERIALIZATION ACE_High_Res_Timer hrTimerBoost; // Load fields into BoostSerializableClass BoostSerializationClass boostSerializationClass( listInteger, listFloat, listLongs, listString); std::ofstream obfile("boost-file.bin"); boost::archive::binary_oarchive oba(obfile); //ACE_Time_Value btvStart = ACE_OS::gettimeofday(); hrTimerBoost.start(); oba & boostSerializationClass; // boost serialization; obfile.close(); hrTimerBoost.stop(); ACE_hrtime_t usecsBoost; hrTimerBoost.elapsed_microseconds(usecsBoost); //ACE_Time_Value btvEnd = ACE_OS::gettimeofday(); //ACE_Time_Value tvIncBoost( btvEnd.sec() - btvStart.sec() , btvEnd.msec() - btvStart.msec() ); std::cout << std:: endl << " ===== BOOST SERIALIZATION =====" ; //std::cout << std::endl << tvIncBoost.sec() << " seconds " << tvIncBoost.msec() << " mseconds" << std::endl ; std::cout << std::endl << usecsBoost << " micro seconds " << std::endl ; // BOOST DESERIALIZACION BoostSerializationClass boostSerializationClass2( listInteger2, listFloat2, listLongs2, listString2); std::ifstream ibfile("boost-file.bin"); boost::archive::binary_iarchive iba(ibfile); //btvStart = ACE_OS::gettimeofday(); hrTimerBoost.reset(); hrTimerBoost.start(); iba & boostSerializationClass2; ibfile.close(); hrTimerBoost.stop(); hrTimerBoost.elapsed_microseconds(usecsBoost); //btvEnd = ACE_OS::gettimeofday(); //tvIncBoost = ACE_Time_Value( btvEnd.sec() - btvStart.sec() , btvEnd.msec() - btvStart.msec() ); std::cout << std:: endl << " ===== BOOST DE-SERIALIZATION =====" ; //std::cout << std::endl << tvIncBoost.sec() << " seconds " << tvIncBoost.msec() << " mseconds" << std::endl ; std::cout << std::endl << usecsBoost << " micro seconds " << std::endl ; ACE_OS::system("pause"); return 0; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// void gen_random_string(std::string &s, const int len) { static const char alphanum[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"; s.clear(); for (int i = 0; i < len ; ++i) { s.push_back(rand() % (sizeof(alphanum) - 1) ); } } Can anyone of you help me with this? Any help would be truly appreciated. Thanks in advance.

4 4

[task][fiber] question about memory leaks
by Dorogan' Konstantin 11 Nov '10

11 Nov '10

Sorry for my "good" english. :) I'am try to use boost.task 0.4.2 in my project. I found some leaks in the files handle.hpp and task.hpp related use_count member initialization. So boost::intrusive_ptr can't release allocated resources. After fixing promblem of the use_count initialization, i ran my unit tests again, but some leaks still living. I discovered that the problem is in the boost.fiber (v 0.5.1). If i try to run compiled unit tests of the boost.fiber manually, the garbage collector of the boost.test shows the leaks. In hopes of finding the place of data leaks, I perform these tests under Rational Purify, but Puify reports that no leaks were detected. Is the garbage collector of the boost.test lies, or the leaks is real!? Tested environment: Windows 7 x64, Windows XP boost 1.42.0 boost.context 0.2.0 boost.task 0.4.2 boost.fiber 0.5.1

1 0

[1.45] Release v trunk, as of r66483
by Jim Bell 11 Nov '10

11 Nov '10

Here's a list of all differences between release and trunk, as of r66483 (this morning). I won't slam the mailing list with its contents, so it's here instead: http://jc-bell.com/files/release-v-trunk-r66483.csv Organized by Folder (2nd column), and it might have a stray false positive or negative since I apply a patch to test. FYI.

5 10

Re: [boost] [msm] Event deferring causes stack overflow
by Christophe Henry 10 Nov '10

10 Nov '10

<snip> >It is not that nice for 2 reasons: > >1. It makes state machine behavior description more splinted in our case to several files ( not a big deal). >2. I have created our own defer functor which logs the event deferral with our logging framework >is there a way do similar function in a state like the no_transition for deferred events where I can implement some generic logging ?. Hi Richard, No, it's not nice. Luckily, last night brought fresh ideas and I implemented a fix. It has to run all regression tests to be 100% sure but it looks good so you can give it a try. For your logging functor, you have to provide a typedef inside the functor definition (like Defer is now doing in functor_row.hpp): typedef int deferring_action; This activates the normal deferred handling and the stack overflow is gone. The fix can be downloaded from the trunk (revision 66490). Unfortunately, it is too late to make it into the 1.45 so be careful if you switch to the new boost release :( I also didn't have time to actualize the doc yet. HTH, Christophe

1 0

[boost.log] Using stream manipulators to influence record formatting per sink
by Jamie Allsop 10 Nov '10

10 Nov '10

So I've been using the previously reviewed log library by Andrey Semashev with some degree of success. One thing however has caused me a great deal of trouble and I'm sure with a couple of changes would become a lot easier. Basically I have an application that outputs tabular data in the logs. I have objects that know how to stream themselves either as an ascii table or as an html table. I have a custom defined manipulator that can be set for a stream that the objects can check the value of, and stream themselves either as text or html as appropriate. In using the log library I face two major challenges. The first is how can I set the manipulator to the desired value so that the log record will be aware of the manipulator while building its message? It is not possible to do this by calling set_formatter() on the sink since the this receives *an already composed* record.message() string. My work-around for this is a lot more complex than I'd like it to be and I'll detail it here in the hope that it provides some insight to Andrey so that he might be able to offer a nicer alternative more in-keeping with his library. So starting at the beginning I have objects that implement streaming something like this: ---- template< class CharT, class Traits> friend std::basic_ostream< CharT, Traits>& operator<<( std::basic_ostream<CharT, Traits>& Ostream, const my_class& Value ) { if( log::output_format::value_in( Ostream ) == log::output_format::text ) { write_text( Ostream, Value ); } else if( log::output_format::value_in( Ostream ) == log::output_format::html ) { write_html( Ostream, Value ); } return Ostream; } ---- where 'value_in()' simply retrieves the value from the stream. Now during logging a temporary stream object is created that must have this manipulator applied. What I'd like to do is be able to specify if I want this manipulator applied on a per-sink basis. In much the same way as I can define a specific formatter for a sink, or a specific filtering rule for a sink. Currently there is no way to do that (at least not without a *lot* of effort) so I'll address this later. Instead I'll consider how we can deal with this be setting this desire globally by using a global attribute. We could write something like this: ---- log::output_format::type OutputFormat = log::output_format::html; std::pair< boost::log::core::attribute_set_type::iterator, bool > OutputFormatAttribute = boost::log::core::get()->add_global_attribute ( "OutputFormat", boost::make_shared< boost::log::attributes::constant<log::output_format::type> >( OutputFormat ) ); ---- Later we can extract this value to decide if we need the manipulator applied to the stream that is used to compose the log record message. We can use a helper object that is aware of all the manipulators that are to be applied and have it the log record stream based on attributes that represent them. For example, given a class called 'manipulators' we can define this insertion operator as: ---- template< class CharT, class TraitsT > inline std::basic_ostream<CharT,TraitsT>& operator<< ( std::basic_ostream<CharT,TraitsT>& Ostream, const manipulators& Manipulators ) { Manipulators.apply( Ostream ); return Ostream; } ---- where apply could be implemented (in our case) as this: --- template< class CharT, class TraitsT > void apply( std::basic_ostream<CharT,TraitsT>& Ostream ) const { boost::log::basic_record<CharT> Record( RecordHandle_ ); apply_output_format( Ostream, Record ); } private: ---- template< class CharT, class TraitsT > void apply_output_format( std::basic_ostream<CharT,TraitsT>& Ostream, const boost::log::basic_record<CharT>& Record ) const { log::output_format::type OutputFormat = log::output_format::text; boost::log::extract<log::output_format::type> ( "OutputFormat", Record.attribute_values(), boost::lambda::var( OutputFormat ) = boost::lambda::_1 ); if( OutputFormat == log::output_format::text ) { Ostream << log::set_output_format( log::output_format::text ); } else if( OutputFormat == log::output_format::html ) { Ostream << log::set_output_format( log::output_format::html ); } } ---- This then requires that the insertion operator is called as part of the streaming for any log record. In order to achieve this I need to write my own logging macros that do essentially what the severity logging macros do already but with the addition of streaming a 'manipulator' object at the same time so that the manipulators I want added can be applied to the stream that is constructed during that process. Here is the key macro that I need to write which gets substituted in a chanin of macros: ---- #define MY_LOG_STREAM_WITH_PARAMS_INTERNAL(logger, rec_var, params_seq)\ for (::boost::log::record_handle rec_var = (logger).open_record((BOOST_PP_SEQ_ENUM(params_seq))).handle(); !!rec_var; rec_var.reset())\ ::boost::log::aux::make_pump_stream((logger), rec_var).stream() << log::manipulators(rec_var) ---- The important part is this: ---- log::manipulators(rec_var) ---- The stream object is created and immediately passed an instance log::manipulators passing the RecordHandle to the constructor. Finally then I can have manipulators passed down to the stream that is used to create the log record message, and in my case allow the logged objects to either stream themselves as text or as html. A downside of this is that this only works with global attributes. So either all log sinks would one format or the other. Given that it is generally desirable to treat different sinks differently (and often the reason they exist) it would be much nice if there was the concept of sink-level attributes. These could be added to the record's attribute set along with the source and global attributes. Currently there is no way (it seems) to associate any state with a sink or make any decision during logging that relates to a sink. We can set a custom formatter that applies to the log message created but that has no effect on the record message itself. (Decorators only seem to be for post-processing of the record message). We can also set a custom filter to determine whether a log record gets logged by a given sink. It seems odd then that we have no way to to be able to say (for example) that a given sink will have an attribute that indicates that all messages through that sink should be in a certain format (for those objects that support the formatting). From looking at the code this does not appear to be a major issue so hopefully it could be supported. It would also be highly desirable to be able to specify manipulators directly that could then be applied to the record message stream itself. Supporting this at the global and sink level should be possible. If we had sink-level attributes the technique I described could be used to simulate this, even though it is somewhat kludgey. Most directed to Andrey, but I'd welcome comments and suggestions from others familiar with the log library. Jamie

2 3

[icl] The Interval Container Library (ICL) moved to the Boost trunk
by Joachim Faulhaber 10 Nov '10

10 Nov '10

Dear All, thank you again for you welcoming comments on the latest version of the now renamed Interval Container Library ICL (formerly Interval Template Library ITL). And thanks to Hartmut for your "invitation" to move the library to the Boost trunk. This might be a small step for Boost but it's a big step for me ;-) I am not sure what has to be done now, so my test suite will be executed in the daily tests that is summarized in the trunk summary on the Boost web-site. I have added my lib into the list in status/Jamfile.v2. I am also wondering how I get information about and deal with errors from those tests on platforms that I can not run on my machine. I didn't find anything about those topics on the Wiki so far. Maybe someone can provide some guidance :) Thanks, Joachim

1 0

[boost.log] set_open_handler() and set_close_handler() for text_multifile_backend?
by Jamie Allsop 10 Nov '10

10 Nov '10

I think it makes a lot of sense for these methods to be available for the text_multifile_backend as they are for the text_file_backend. My use case is that I am logging data out in html format and being able to log data out as individual html files for browsing through later on. Being able to have an html header and footer added as files are opened and closed makes a lot of sense for this backend. Jamie

2 4

[optional] swap not a member of boost::optional
by Eric Niebler 10 Nov '10

10 Nov '10

It seems like boost::optional has a swap member function on trunk but not on release, and it's been this way for a few releases already. Can we get this inconsistency resolved? I've been bitten by it a few times already when merging things to the release branch. -- Eric Niebler BoostPro Computing http://www.boostpro.com

1 1

[graph] Kudos!
by K. Noel Belcourt 10 Nov '10

10 Nov '10

Hi, Just wanted to say nice job to Jeremiah Willcock!! Found this killer graph on page 5: http://www.sandia.gov/LabNews/ln11-05-10/labnews11-05-10.pdf I probably cut the citation off (it reads: Graph courtesy of Jeremiah Willcock, Indiana University). Guessing this was generated with pBGL? -- Noel

1 0

[fusion] rev. 66411 breaks VC 8.0
by Ralf W. Grosse-Kunstleve 10 Nov '10

10 Nov '10

minimal.cpp: #include <boost/fusion/sequence/comparison/less_equal.hpp> cl /c /EHsc /I..\hot\boost minimal.cpp Gives the error below. It works with rev. 66410 but not 66411 (and still not with current 66472): % svn log -v -c66411 ------------------------------------------------------------------------ r66411 | cschmidt | 2010-11-06 05:21:18 -0700 (Sat, 06 Nov 2010) | 1 line Changed paths: M /trunk/boost/fusion/container/deque/deque.hpp A /trunk/boost/fusion/container/deque/detail/is_sequence_impl.hpp M /trunk/boost/fusion/container/vector/detail/vector_n.hpp M /trunk/boost/fusion/sequence/comparison/detail/enable_comparison.hpp M /trunk/boost/fusion/support/detail/is_mpl_sequence.hpp M /trunk/boost/fusion/support/is_sequence.hpp M /trunk/boost/fusion/support/sequence_base.hpp Fusion: removed fusion::sequence_root; Fixes #2335 ------------------------------------------------------------------------ ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2039: 'is_native_fusion_sequence' : is not a member of 'boost::fusion::detail' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2065: 'is_native_fusion_sequence' : undeclared identifier ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2974: 'boost::disable_if' : invalid template argument for 'Cond', type expected ..\hot\boost\boost/utility/enable_if.hpp(59) : see declaration of 'boost ::disable_if' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2988: unrecognizable template declaration/definition ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2059: syntax error : ',' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(48) : error C2039: 'type' : is not a member of '`global namespace'' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(55) : error C2039: 'is_native_fusion_sequence' : is not a member of 'boost::fusion::detail' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(55) : error C2974: 'boost::disable_if' : invalid template argument for 'Cond', type expected ..\hot\boost\boost/utility/enable_if.hpp(59) : see declaration of 'boost ::disable_if' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(56) : error C2039: 'type' : is not a member of '`global namespace'' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(57) : error C2143: syntax error : missing ';' before '{' ..\hot\boost\boost/fusion/sequence/comparison/less_equal.hpp(57) : error C2447: '{' : missing function header (old-style formal list?)

2 2

Showstopper ticket #4736 not in trunk or release
by Jim Bell 10 Nov '10

10 Nov '10

The patch for showstopper ticket # 4736 isn't in either the trunk or release branches as of this morning (r66453). Did it get missed?

3 7

MinGW's last thread/tss problem: fixable?
by Jim Bell 10 Nov '10

10 Nov '10

Thread is still failing test_tss_lib, now with this... ../libs/thread/test/test_tss.cpp(181): error in "test_tss": Support of automatic tss cleanup for native threading API not available If I understand this correctly, the tss cleanup will never be called for a thread created via the native API. There's no global function that can force a clean-up because nothing can force the underlying thread mechanism to return the thread-specific value for a thread that's already exited. I see some subtle magic in libs/thread/src/win32/tss_pe.cpp, some even for __MINGW32_... Is this for static libs? Any chance we can make that work for MinGW's gcc-4.3.3 and gcc-4.4.0? Also, I think the docs need a "Note" section describing this issue, say thread_local_storage.html, inside the section "Cleanup at thread exit".

2 1

Re: [boost] [Review] Formal Review of Proposed Boost.Chrono LibraryStarts TOMORROW
by Aaron Graham 10 Nov '10

10 Nov '10

See this gcc bugzilla entry for a discussion I've had about chrono support in the gcc implementation. http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41861 Unfortunately, monotonic_clock support, even if it exists, is a transparent lie. It's not so much a problem with the chrono library as it is a problem with the thread library's use of chrono. A monotonic clock is used to provide somewhat accurate/reliable wait times even in the face of changing clocks, especially in the case of mutexes and condition variables. When condition::wait_until is called with a monotonic_clock time_point, that time_point is translated to a system_clock time_point. If the system_clock is changed (via NTP, adjtime, settimeofday, etc) between when convert_to<system_clock> is called and when the underlying posix call is made, the very reason for using monotonic_clock defenestrates and splatters all over the pavement. Depending on the magnitude of the clock change, wait_until could hang forever. In my opinion, all convert_to calls in the thread library should go to the monotonic_clock, if available. Not system_clock. I couldn't get the gcc people to understand this, so I won't be able to use <chrono> in the standard library sans modification. Maybe boost will get it right? Let me know if I'm missing a subtle point that moots my concerns. Other than that, I think the this library is great. I need it badly. I haven't looked over all the code yet, but what I've seen looks good.

3 2

mkl+boost problems
by Andrey Asadchev 10 Nov '10

10 Nov '10

Hello. mkl (intel blas) has "mkl_cblas.h" file which in turn includes " mkl_types.h" file which defines P4 macro variable: 70 /** CPU codes for int MKL_CPU_DETECT(void) **/ 71 #ifdef _IPF 72 #define ITP 0 73 #else 74 #ifdef _EM64T 75 #define NI 0 76 #define CT 1 77 #define MNI 2 78 #define PNR 3 79 #else 80 #define DEF 0 81 #define PIII 1 82 #define P4 2 83 #define P4P 3 84 #define P4M 4 85 #endif 86 #endif This P4 variable creates havoc of MPL templates which have P4 template parameters names. What to do?

9 10

Re: [boost] [msm] Event deferring causes stack overflow
by Christophe Henry 09 Nov '10

09 Nov '10

> Hi All > > We have found a serious problem in msm back end for event deferring. > I case there is a composite state and the outer state machine defers 2 > events when it is in the composite state, the 1st event deferred fine > in the deferred queue of the outer state machine. > Than the 2nd event is processed and this is deferred as well as a part > of this deferral msm back end dispatches the 1st event but it is still > deferred and saved again in the deferred queue but than msm processes > the deferred queue again as an action of the deferral of the 1st event > and dispatches the 2nd event again which is deferred and the cycle > repeats itself until the system runs out of call stack. Hi, No, it's not that serious, but still not nice. The problem is that the principle of the Defer functor is not working and I am wondering if I should keep it. To make short, Defer is an action, and for all front-ends, actions return void. This has the unintended effect of marking the transition results as "handled" instead of "deferred", which breaks my defensive measures. If you replace the transitions by the standard UML method of marking the state as deferring (through the deferred_events typedef), you have no more stack overflow. Now I understand that the Defer functor is cool and offering to remove it is guaranteed to cause disappointment, so I see 2 possibilities: - explaining its limitations in the doc - making a change to all front-ends for this special case to work around the fact that actions return void For the meantime, use the "normal" way and I will see if I find a workaround. Cheers, Christophe

2 1

[mpl] mpl::c_str fails for mpl::push_back
by vicente.botet 09 Nov '10

09 Nov '10

Hi, the following results in a compile error for msvc-10.0. It works for gcc-3.4, gcc-4.3, gcc-4.5. typedef mpl::vector_c<char, 'h','e','l','l','o',' ','w','o','r','l','d'> hello; typedef mpl::push_back<hello, mpl::char_<'!'> >::type hello2; BOOST_TEST((std::string(mpl::c_str<hello2>::value)== "hello world!")); // line 59 C:\cygwin\boost\v44\boost/mpl/string.hpp(592) : error C2039: 'value_type' : is not a member of 'boost::mpl::vector12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>' with [ T0=boost::mpl::integral_c<char,104>, T1=boost::mpl::integral_c<char,101>, T2=boost::mpl::integral_c<char,108>, T3=boost::mpl::integral_c<char,108>, T4=boost::mpl::integral_c<char,111>, T5=boost::mpl::integral_c<char,32>, T6=boost::mpl::integral_c<char,119>, T7=boost::mpl::integral_c<char,111>, T8=boost::mpl::integral_c<char,114>, T9=boost::mpl::integral_c<char,108>, T10=boost::mpl::integral_c<char,100>, T11=boost::mpl::char_<33> ] io\match_pass.cpp(59) : see reference to class template instantiation 'boost::mpl::c_str<Sequence>' being compiled with [ Sequence=hello2 ] Is this a known bug? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

3 13

[msm] Event deferring causes stack overflow
by Richard Szabo 09 Nov '10

09 Nov '10

Hi All We have found a serious problem in msm back end for event deferring. I case there is a composite state and the outer state machine defers 2 events when it is in the composite state, the 1st event deferred fine in the deferred queue of the outer state machine. Than the 2nd event is processed and this is deferred as well as a part of this deferral msm back end dispatches the 1st event but it is still deferred and saved again in the deferred queue but than msm processes the deferred queue again as an action of the deferral of the 1st event and dispatches the 2nd event again which is deferred and the cycle repeats itself until the system runs out of call stack. please find the code to reproduce the problem in attachment. thanks for the help in advance. Br. Richie

1 0

Boost and (Microsoft's) _SECURE_SCL
by Martin B. 09 Nov '10

09 Nov '10

Boost and Microsoft's _SECURE_SCL Long story short of this post: Are there any plans (left) to add additional name mangling to the boost libs on Windows to address the problem of mismatched _SECURE_SCL setting? The Microsoft (Dinkumware) _SECURE_SCL=1 macro [1],[2] adds additional checks to standard library iterators/containers, rendering them ABI incompatible with _SECURE_SCL setting 0 vs. 1. This in turn leads to crashes when using a wrong combination of this flag. For example: [3] This has been discussed numerous times before: [4], [5], [6] -- see [5] for a list of further links to more threads. A trac issue [7] to add a specific build option has been closed as invalid. What I have been unable to determine is what the status is on supporting an additional *name mangling scheme* for the _SECURE_SCL option. From what I can discern from the current Getting Started page [8], not only do we not support any such name mangling, but the _SECURE_SCL macro (or the new _ITERATOR_DEBUG_LEVEL macro in VS2010) is not even mentioned on the Getting Started page. Since Visual Studio 2005 defaulted to _SECURE_SCL=1 and boost just uses the default, many people hit this when they used _SECURE_SCL=0 to improve performance in their release builds. (Which, as an aside, doesn't yield too much, as the real showstopper is the - independent! - _HAS_ITERATOR_DEBUGGING macro and that is only active in debug builds anyway.) In Visual Studio 2010, the situation is reversed, as Microsoft decided to now default to _SECURE_SCL=0. That means the people who change it to 1 in their release build for additional security will be bitten by the problem. (Or not, as it seems that they added some link-time checks in VS2010 to detect mismatches regarding the _ITERATOR_DEBUG_LEVEL. [9]) OK, so now again: Are there any plans (left) to add additional name mangling to the boost libs on Windows to address the problem of mismatched _SECURE_SCL setting? -- Or are we just going to ignore the issue since VS2010 defaults to the "boost preferred" - off - option now anyway? By "boost preferred" I mean that from some of the discussions it seemed to me that there was doubts w/rgd to complexity issues etc. when _SECURE_SCL is on. cheers, Martin p.s.: FWIW, here's how /I/ compile my release version of boost 1.44 on VS2005: bjam.exe --build-type=complete variant=release toolset=msvc-8.0 threading=multi define=_SECURE_SCL=0 --with-regex --with-program_options --with-test --with-serialization stage [1] Visual Studio 2005 - _SECURE_SCL : http://msdn.microsoft.com/en-us/library/aa985896%28VS.80%29.aspx [2] Visual Studio 2010 - _SECURE SCL : http://msdn.microsoft.com/en-us/library/aa985896%28v=VS.100%29.aspx [3] access violation with _SECURE_SCL turned off : http://lists.boost.org/boost-users/2009/02/45137.php [4] _SECURE_SCL for msvc (2009) : http://thread.gmane.org/gmane.comp.lib.boost.devel/185898/focus=185987 [5] MSVC _SECURE_SCL causes ABI change, ODR violation - mangle library names? : http://lists.boost.org/boost-users/2008/10/41253.php [6] Re: Bug/Incompatibility: Visual C++ 2005 checkediteratorslead to major crashes : http://thread.gmane.org/gmane.comp.lib.boost.devel/144082/focus=144089 [7] Add build option to define _secure_scl=0 + add runtime check to ensure no ODR violation : https://svn.boost.org/trac/boost/ticket/2086 [8] Boost 1.44 Getting Started on Windows : http://www.boost.org/doc/libs/1_44_0/more/getting_started/windows.html [9] Visual STuduio 2010 - detect_mismatch : http://msdn.microsoft.com/en-us/library/ee956429.aspx

5 11

encryption?
by Brian Wood 09 Nov '10

09 Nov '10

I recall a few threads on the subject of a fledgling Boost Encryption library, but haven't seen anything about it recently. Could someone update me on this? I've used OpenSSL enough to desire a C++ alternative. (Imagine some existing Boost libs written in C.) -- Brian Wood Ebenezer Enterprises http://webEbenezer.net (651) 251-9384 "The kingdom of heaven is like a treasure hidden in the field, which a man found and hid again; and from joy over it he goes and sells all that he has and buys that field."

1 0

[function] new implementation
by Domagoj Saric 09 Nov '10

09 Nov '10

Hi, <...those that followed the latest function related discussions can skip the first paragraph...> For about a year and half now (or even more but that's about how long I've been involved in the matter) there have been repeated discussions/requests/complaints about various aspects of Boost.Function. Most of those fall into one or more of these categories: - overall code speed overhead - overall code bloat overhead - lack of configurability - dependencies on RTTI and exception handling with the most frequently brought up specific issue being the various implications (in all of the above mentioned areas) of the hardcoded throw-on-empty behaviour... Unfortunately Boost.Function code remained virtually unchanged (except for the added RTTI emulation for platforms w/o RTTI support) with all of the issues still remaining... The new implementation proposal @: https://svn.boost.org/svn/boost/sandbox/function/boost/function http://www.boostpro.com/vault/index.php?&direction=0&order=&directory=Funct… Objects solves or at least provides drastic improvements for all of the mentioned issues. It is intended as a drop in replacement for the current implementation and as such I have so far tested it in the following ways: - compiling some real world code: VC10, GCC 4.2.1, LLVM-GCC 4.2.1, GCC 4.5.1, GCC 4.6, Clang 2.0, Clang 2.8 - compiling and running a real world project: VC10, Clang 2.8 - building Boost trunk: VC10, GCC 4.2.1, GCC 4.5.1, Clang 2.0 - running Boost regression tests for Function, Signals, Signals2, Thread, Program Options and Graph libraries: VC10, GCC 4.2.1, Clang 2.0. (All of the tests passed except for two bogus assertion failure boxes that pop up with VC10 and the Program Options tests during the automated regression test procedure that OTOH do not popup when I run the same tests manually through the VC10 IDE, i.e. the tests finish successfully...I tried to make sure all the relevant compiler switches were the same in both cases so I am out of ideas what else can make the difference.....) Next, let me give you a comparison of for-size-optimized code generated by VC10 with both the current and the proposed implementation for a short code snippet demonstrating invocation, construction and assignment: struct X { int foo( int const x ) const { return x + y; }; int y; }; int main( int /*argc*/, char * * /*argv*/ ) { using namespace boost; X x; function<int(int)> foof( boost::bind( &X::foo, &x, _1 ) ); foof( 0 ); function<int(int)> barf; barf = foof; barf( 1 ); return 0; } Notice in new_function_code_listing.txt how all of the wrapper code in the new Function was completely transparent to the compiler and was completely inlined to relatively simple machine code with direct calls to/through the vtable pointers...while OTOH in current_function_code_listing.txt the code generated for the "barf = foof;" assignement alone is several times larger than the entire code generated for the new Function implementation. The small asm snippet of the generated invoker/'thunk'/'trampoline' code also demonstrates the effects of various tweaks done to minimize or all together remove the need for any stack adjustment on the invoker side... The new implementation of course has the same semantics and exception safety guarantee levels as the original/current one. Listing all of the improvements and detailed implementation changes here in the first post would be quite cluttering as they are quite numerous. Those that desire more tests and details right now, can follow this trail: http://lists.boost.org/Archives/boost/2010/01/160908.php As for the dependencies issue this is solved in several ways: - use of exception handling: new code uses guard objects instead of explicit exception handling and provides a way to change on-empty-behaviour so that the EH code/dependency can easily be removed/disabled - use of RTTI (for getting the type of the stored function object): this can be globally disabled with the BOOST_FUNCTION_NO_RTTI macro. BOOST_NO_RTTI is not used for this purpose for backward compatibility reasons: in the current implementation it actually turns on RTTI emulation...The idea is to also add per instantiation RTTI on-off configurability... 'Configurability' will probably be the most controversial issue/change because it required the addition of an extra template parameter through which an MPL list of policies can be specified at compile-time. This parameter is properly defaulted to allow existing code to compile without changes while providing current Boost.Function behaviour (e.g. on-empty- behaviour). As all the performed tests showed this to also be true in practice the proposed code should IMO go in as a straight drop-in replacement but, of course, I might have missed some important higher level detail/concern so this is open to discussion... Currently two policies are supported: - on throw behaviour (with throw-on-empty, nop-on-empty and assert-on-empty handlers provided) - whether the function instantiation should mark itself (i.e. its operator()) as nothrow. Additional policies my be added later, for example: - sizeof and/or alignment of the SBO buffer - default allocator - per instantiation RTTI on/off ... Finally, there is one more addition, somewhat 'unholy' as it brings in the concept of binding into Boost.Function but considering its efficiency and/or verbosity benefits (and the fact that the first issue can be 'explained away' by saying that this is not actually 'binding' but a workaround for the lack-of-delegates-support C++ language deficiency). The addition is in the form of two more assign() member function overloads (one for a free function that has the exact signature as the Boost.Function instantiation, and one for a member function that has a matching signature with the addition of a this pointer) that allow assignment of (suitably typed) plain (free or member) functions specified as non-type-template parameters. This allows for the removal of the extra indirect-call-through-function-pointer otherwise incurred by traditional assignment of function pointers (not functors), which is actually a rather common use case. For example, in the above example given, one can now write: foof.assign<X, &X::foo>( x ); and get a trivial invoker with the X::foo() target function inlined straight in... -- "What Huxley teaches is that in the age of advanced technology, spiritual devastation is more likely to come from an enemy with a smiling face than from one whose countenance exudes suspicion and hate." Neil Postman

7 27

Will test/doc be merged?
by Jim Bell 08 Nov '10

08 Nov '10

Looks like a lot of changes to test/doc and subdirectories were committed to the trunk on 6/10/2010. They fix at least one problem I saw. (doc/html/index.html, BOOST_TEST_PASSPOINT points to "Logging floating point type numbers", which is in the mis-named file BOOST_TEST_PASSPOINT.html.) Anyone know the status? Can it be merged into the release?

1 0

[multi_index] scalar insert interface
by Maxim Yegorushkin 08 Nov '10

08 Nov '10

Hey guys, In ordered_index there are two scalar insert overloads: std::pair<iterator,bool> insert(const value_type& x); iterator insert(iterator position,const value_type& x); The second version is lacking the bool result, which is sometimes required. In my source code of boost-1_42 I patched the second version like this: ==== .../ordered_index.hpp#2 (text) ==== @@ -97,6 +99,16 @@ struct ordered_unique_tag{}; struct ordered_non_unique_tag{}; +template<class T, class U> +struct auto_cast_pair : std::pair<T, U> +{ + typedef std::pair<T, U> base_pair; + auto_cast_pair(base_pair const& b) : base_pair(b) {} + using base_pair::operator=; + operator T&() { return this->first; } + operator T const&() const { return this->first; } +}; + template< typename KeyFromValue,typename Compare, typename SuperMeta,typename TagList,typename Category @@ -274,14 +286,14 @@ return std::pair<iterator,bool>(make_iterator(p.first),p.second); } - iterator insert(iterator position,value_param_type x) + auto_cast_pair<iterator,bool> insert(iterator position,value_param_type x) { BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this); BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT; std::pair<final_node_type*,bool> p=this->final_insert_( x,static_cast<final_node_type*>(position.get_node())); - return make_iterator(p.first); + return std::pair<iterator,bool>(make_iterator(p.first),p.second); } template<typename InputIterator> Now it automatically figures which return value one wants. Just an idea. -- Max

4 5

[mpl] map insert
by vicente.botet 08 Nov '10

08 Nov '10

Hi, in /libs/mpl/doc/refmanual/map.html insert<m,x>::type point to the description of insert<m,pos,x>::type. In addition I don't find the descrition of insert<m,x>::type in libs/mpl/doc/refmanual/intrinsic-metafunctions.html Can this be added? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

2 2

Re: [boost] [Boost-commit] svn:boost r66442 - in trunk/boost: math/tools test test/impl
by Jürgen Hunold 08 Nov '10

08 Nov '10

Hi ! On Sunday, 7. November 2010 21:05:06 admin(a)thefireflyproject.us wrote: > Author: wash > Date: 2010-11-07 15:05:04 EST (Sun, 07 Nov 2010) > New Revision: 66442 > URL: http://svn.boost.org/trac/boost/changeset/66442 > > Log: > Clang hand-holding, mostly for issues caused by Clang defining GCC macros. I do not think that removing the inclusion of "fenv.h" for clang is the right solution. According to http://llvm.org/bugs/show_bug.cgi?id=6907 it is a known compiler bug that clang fails to correctly load "fenv.h" in certain environments (several gcc versions installed...) I've been working around this by simply adding (see below) > Text files modified: > trunk/boost/math/tools/config.hpp | 2 +- > trunk/boost/test/execution_monitor.hpp | 15 ++++++++------- > trunk/boost/test/impl/execution_monitor.ipp | 18 +++++++++--------- > 3 files changed, 18 insertions(+), 17 deletions(-) > > Modified: trunk/boost/math/tools/config.hpp > =========================================================================== > === --- trunk/boost/math/tools/config.hpp (original) > +++ trunk/boost/math/tools/config.hpp 2010-11-07 15:05:04 EST (Sun, 07 > Nov 2010) @@ -255,7 +255,7 @@ > } // namespace tools > }} // namespace boost namespace math > > -#if (defined(__linux__) && !defined(__UCLIBC__)) || defined(__QNX__) || > defined(__IBMCPP__) +#if (defined(__linux__) && !defined(__UCLIBC__) && > !defined(__clang__)) || defined(__QNX__) || defined(__IBMCPP__) > > #include <fenv.h> #if defined(__clang__) #include </usr/include/fenvh.> #else for my local working copies. > return ~old_cw & BOOST_FPE_ALL; > -#elif defined(__GLIBC__) && defined(__USE_GNU) > +#elif defined(__GLIBC__) && defined(__USE_GNU) && !defined(BOOST_CLANG) > > ::feclearexcept(BOOST_FPE_ALL); And this actually removes fp-Support from Boost.Test. Not good. Please find a better solution. And/Or mark the relevant places with Todo containing a reference to the clang bug report. Yours, Jürgen -- * Dipl.-Math. Jürgen Hunold ! Ingenieurgesellschaft für * voice: ++49 511 262926 57 ! Verkehrs- und Eisenbahnwesen mbH * fax : ++49 511 262926 99 ! Lister Straße 15 * juergen.hunold(a)ivembh.de ! www.ivembh.de * * Geschäftsführer: ! Sitz des Unternehmens: Hannover * Prof. Dr.-Ing. Thomas Siefer ! Amtsgericht Hannover, HRB 56965 * PD Dr.-Ing. Alfons Radtke !

3 4

[mpl] What about wstring, u16string and u32string
by vicente.botet 08 Nov '10

08 Nov '10

Hi, I was considering to use mpl::string to implement chrono_io but I see that there are not the couterparts wstring, u16string and u32string. Without these classes I could not use the mpl strings. Is there a possibility to add these classes to Boost.Mpl? Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

3 2

Re: [boost] [Boost-commit] svn:boost r66441 - in trunk/tools/build/v2: . engine/src engine/src/modules tools
by Jürgen Hunold 08 Nov '10

08 Nov '10

Hi ! On Sunday, 7. November 2010 20:51:11 admin(a)thefireflyproject.us wrote: > Modified: trunk/tools/build/v2/engine/src/modules/order.c > =========================================================================== > === --- trunk/tools/build/v2/engine/src/modules/order.c (original) +++ > trunk/tools/build/v2/engine/src/modules/order.c 2010-11-07 14:51:05 > EST (Sun, 07 Nov 2010) @@ -50,8 +50,8 @@ > > if (colors[adjacent_vertex] == white) > do_ts(graph, adjacent_vertex, colors, result_ptr); > - else if (colors[adjacent_vertex] == gray) > - ; /* This is loop. Not sure what to do... */ > + //else if (colors[adjacent_vertex] == gray) > + //; /* This is loop. Not sure what to do... */ > } > colors[current_vertex] = black; > **result_ptr = current_vertex; Are you sure that you really wanted to commit this ? Yours, Jürgen -- * Dipl.-Math. Jürgen Hunold ! Ingenieurgesellschaft für * voice: ++49 511 262926 57 ! Verkehrs- und Eisenbahnwesen mbH * fax : ++49 511 262926 99 ! Lister Straße 15 * juergen.hunold(a)ivembh.de ! www.ivembh.de * * Geschäftsführer: ! Sitz des Unternehmens: Hannover * Prof. Dr.-Ing. Thomas Siefer ! Amtsgericht Hannover, HRB 56965 * PD Dr.-Ing. Alfons Radtke !

3 3

Re: [boost] [ptr_container] [1.45] you own a showstopper
by Thorsten Ottosen 07 Nov '10

07 Nov '10

Den 07-11-2010 23:05, Eric Niebler skrev: > Thorsten, > > The following bug in ptr_container is marked as a Showstopper for the > 1.45 release. What are your plans for it? If you're planning on fixing > it, can you do so soon? If you feel it is not a showstopper, can you set > its priority appropriately? > > https://svn.boost.org/trac/boost/ticket/4598 Should hav been fixed for a day or more. -Thorsten

2 2

[ptr_container] [1.45] you own a showstopper
by Eric Niebler 07 Nov '10

07 Nov '10

Thorsten, The following bug in ptr_container is marked as a Showstopper for the 1.45 release. What are your plans for it? If you're planning on fixing it, can you do so soon? If you feel it is not a showstopper, can you set its priority appropriately? https://svn.boost.org/trac/boost/ticket/4598 Thanks, -- Eric Niebler BoostPro Computing http://www.boostpro.com

1 0

[property_tree] [1.44] you own a showstopper
by Eric Niebler 07 Nov '10

07 Nov '10

Sebastian, The following bug in property_tree is marked as a Showstopper for the 1.44 release. What are your plans for it? If you're planning on fixing it, can you do so soon? If you feel it is not a showstopper, can you set its priority appropriately? Thanks, -- Eric Niebler BoostPro Computing http://www.boostpro.com

1 1

[function] does calling boost::function from boost::function involve nested virtual calls?
by Mostafa 07 Nov '10

07 Nov '10

Hi all, Correct me if I'm wrong, using boost::function involves a virtual function call. If so, then does nesting boost::function calls result in nested (multiple) virtual function calls? For example: int foo(float); boost::function<int (float)> f1 = foo; boost::function<double (int)> f2 = f1; Does f2(5) result in two virtual functions being called on the part of boost::function? (I couldn't find the answer in the documentation and reading the source code I got lost in the macros.) Thanks, Mostafa

2 1

[build] print test failing on release
by Eric Niebler 06 Nov '10

06 Nov '10

Volodya, can you investigate the failure of the Boost.build "print" test on the release branch? It's currently failing across all platforms. Thanks, -- Eric Niebler BoostPro Computing http://www.boostpro.com

2 3

[type traits] is_virtual_base_of causes C4250 (class inherits member via dominance) with VS 2005
by Martin B. 06 Nov '10

06 Nov '10

Hi! I didn't find any references to this, so I thought I'd let you know that boost::is_virtual_base_of<Base, Derived> will cause (harmless) C4250 when evaluating to true. (VC++ 2005) I hit this when using the BOOST_CLASS_EXPORT macro from Boost.Serialization, as this uses is_virtual_base_of internally. cheers, Martin ps: For code see: http://stackoverflow.com/q/4091166/321013

3 2

[icl/itl] Interval Container Library ready for inclusion
by Joachim Faulhaber 06 Nov '10

06 Nov '10

Dear list! After the review of the Interval Template Library in February and its acceptance for inclusion, I worked on a number of suggestions and proposals from the reviewers, in order to improve the design and quality of the library. The library is now renamed to Boost.Icl: Interval Container Library. I have completed a release icl-4.0.0, where those suggestions are implemented. Apart from typos and flaws in the docs that might be there after renaming, this will be the version for inclusion into the next boost release (1.46.0). The now renamed library has a new path in the sandbox: https://svn.boost.org/svn/boost/sandbox/icl/ The sources are also in the vault http://www.boostpro.com/vault/index.php?&direction=0&order=&directory=Conta… and on sourceforge (extended version) http://sourceforge.net/projects/itl/ The BoostBook docs are online available here: http://www.joachim-faulhaber.de/boost_icl/doc/libs/icl/doc/html/index.html Many of the proposals from the reviewers were agreed upon during the discussion on the library. In particular I took into account suggestions by Jeff Flinn (JF), Luke Simonson (LS), Barend Gehrels (BG), Vicente Botet (VB), Thomas Klimpel (TK), Paul A. Bristow (PB), Robert Stewart (RS), John Reid (JR) and Markus Werle (MW). Some suggestions by Phil Endecott, Jerry Jeremiah, Brian Wood, Barend Gehrels, Luke Simonson and John Reid are not or not yet implemented for different reasons but they may be considered for the future evolution of the library. * The library has been renamed from Interval Template Library (ITL) to Interval Container Library (ICL) Its namespace is now icl instead of itl. (Renaming was suggested by MW). * Introduction of dynamically bounded and statically bounded intervals (JF,JR,VB) + The 'universal' interval class itl::interval has been replaced by + dynamically bounded discrete_interval and continuous_interval http://www.herold-faulhaber.de/boost_icl/doc/libs/icl/doc/html/boost_icl/ex… + statically bounded right_open_interval, left_open_interval closed_interval and open_interval and a uniform set of namespace global functions or interval_concept for them. Statically bounded intervals don't carry information about their interval bounds and use less memory. (JF,JR) http://www.herold-faulhaber.de/boost_icl/doc/libs/icl/doc/html/boost_icl/ex… + The interval class templates are now quite small. The functions are namespace global functions that make up an interval concept (JF,LS) + Added functions 'distance' and 'inner_complement' for intervals.(JR) http://www.herold-faulhaber.de/boost_icl/doc/libs/icl/doc/html/boost_icl/fu… * User defined interval types are now customizable (JF) + An interval_traits and dynamic_interval_traits template describes the generic properties of the interval concept ... + and allows to customize the icl library for user defined interval types. http://www.herold-faulhaber.de/boost_icl/doc/libs/icl/doc/html/boost_icl/ex… * Extraction of namespace global functions. (LS,JF,RS) + Member functions have been extracted form class templates as long as they are not needed to maintain type invariants. + The sets of namespace global functions build concepts icl::element_set, icl::element_map, icl::interval_set, icl::interval_map + Some functions have been renamed to conform existing standards (ISO/OGC). (BG) + std::set and other stl conformant set types are models of the icl's element_set concept. Class template icl::set has been removed. + Member functions for element iterations are extracted from the interval container class templates. (LS) * Names, referred to as 'colorful terminology' have been renamed (TK,VB,PB) + neutron -> identity_element + unon -> unit_element + ... and also their occurrence in composite identifiers If you find bugs in the library or typos or other flaws in the docs, please let me know so I can fix them before inclusion of the library into the next boost release. Enjoy, Joachim

5 4

bjam in lib/<x>/test is equivalent to run.py
by Jim Bell 06 Nov '10

06 Nov '10

Compelled as I am to audit everything, I had to compare running bjam in the lib/<x>/test directory with run.py. I'm confident that they do produce (essentially) the same compile, link, and execute commands. Notes, from a regression-runner's POV: * They use different directories: run.py uses {boost-root}/../results/bin.v2/..., and bjam uses {boost-root}/bin.v2/... * run.py sets up bjam with a lot of flags, like --debug-configuration [shouldn't matter for most people] -d2 [important for many, described below] -lxxx [that's lower-case L, with a time-out in seconds: potentially important] preserve-test-targets=off [not sure if this matters or not] * run.py runs from the boost/status directory, I think. Might matter for some tests. Not sure about straight bjam. To make your own script to rebuild/rerun a particular test, run bjam with -d+2 (i.e., -d2) and direct the output to a file. Then copy the compile & link commands out of that file. The -lxxx command (e.g., -l120) matters if a test could hang (e.g., <https://svn.boost.org/trac/boost/ticket/4766>).

3 5

Re: [boost] [Boost-users] [icl/itl] Interval Container Library ready for inclusion
by Joachim Faulhaber 05 Nov '10

05 Nov '10

2010/11/5 Jeff Flinn <TriumphSprint2000(a)hotmail.com>: > Hartmut Kaiser wrote: >>> >>> After the review of the Interval Template Library in February and its >>> acceptance for inclusion, I worked on a number of suggestions and >>> proposals from the reviewers, in order to improve the design and quality >>> of the library. The library is now renamed to Boost.Icl: Interval >>> Container Library. >>> >>> I have completed a release icl-4.0.0, where those suggestions are >>> implemented. Apart from typos and flaws in the docs that might be there >>> after renaming, this will be the version for inclusion into the next >>> boost >>> release (1.46.0). >>> >>> The now renamed library has a new path in the sandbox: >>> https://svn.boost.org/svn/boost/sandbox/icl/ >>> >>> The sources are also in the vault >>> >>> http://www.boostpro.com/vault/index.php?&direction=0&order=&directory=Cont >>> ainers >>> >>> and on sourceforge (extended version) >>> http://sourceforge.net/projects/itl/ >>> >>> The BoostBook docs are online available here: >>> >>> http://www.joachim-faulhaber.de/boost_icl/doc/libs/icl/doc/html/index.html >> >> Joachim, that's great news. Many people are waiting for this! > > Awesome! I'm looking forward to working with the final result. > >> Why don't you just go ahead and move everything into Boost trunk. That >> does >> not disrupt any release procedures, but gives you the benefit of running >> the >> tests on a daily basis on a broad range of platforms. Additionally it >> simplifies things for people working from Boost SVN trunk wanting to use >> your library. > > Yep, that would be great. Thank you all for your welcoming remarks on the new version of the Interval Container Library. Yes, I am prepared to move this version of the ICL into the Boost trunk, but I don't have write permission yet. How do I get it? Are there any special policies to follow when working with the Boost trunk? Best regards, Joachim

2 1

[Boost.config] User.hpp for new PGI 10.9 compiler
by K. Noel Belcourt 05 Nov '10

05 Nov '10

Hi, Can a Boost.config developer take a look at the attached user.hpp generated by the configure script for the pgi-10.9 toolset? Are there any obvious changes necessary to boost/config/compiler/pgi.hpp? Thanks. -- Noel

2 5

Best method of checking for ==, <, streamability
by Christopher Jefferson 05 Nov '10

05 Nov '10

A user recently posted on boost-users asking for operator== support in boost::any. I have added this support to my private version, which extends spirit's implementation of any. I am interested in cleaning this up and submitting it to replace boost::any, if everyone is happy with this. The major issue is that my implementation requires type support operator==, operator< , hash and operator<< / operator>>. Are there any techniques in boost for detecting the presence of these operators which are sufficiently reliable they could be used in boost::any? Apologises for this question, but I have lost track of how well such checks can be implemented. Thanks, Christopher Jefferson

5 4

How about a call for bug-fix volunteers?
by Jim Bell 05 Nov '10

05 Nov '10

Library authors shouldn't have to bear the burden of bug reports for their libraries alone. Even maintaining their regression tests across all platforms isn't realistic (and isn't being done). So what if we try to recruit a couple helpers for each library? I see two avenues where we can use some volunteer help to improve boost's quality. 1. Dandelion pickers: look at failed/yellow regression tests and try to fix them. Volunteers could pick a platform they have access to, and try to work across all libraries. You might be surprised at how easy many are to fix. 2. Ticket triage: pick a library and go through all open tickets. Change severity, resolve, request more information, try to map to an existing regression test, interact with the submitter in the comments. (I think Trac needs a "requesting more information" state.) Even a brief 'triage' on each would be helpful, and help users feel they're being heard. (Trac needs to track this, too.) Write new regressions from legitimate issues. Recruiting pitch: it's a great way to improve your skills--troubleshooting, C++, platform-specific expertise, communication. Not so glamorous, but important and great experience. Perhaps we could assign a little of each to each SoC person. Maybe put the word out on Slashdot. See previous topic threads (http://lists.boost.org/Archives/boost/2010/10/index.php) "Report # 29 (aka 1.45 blockers) is too narrow" "[1.45] Beta final schedule" "[1.45] Thread issues"

14 18

Named subexpressions using \k<name>
by Chris Dragon 04 Nov '10

04 Nov '10

I have a user who says they have a bunch of expressions written for the Oniguruma regex library that use \k<name> syntax. According to http://www.boost.org/doc/libs/1_44_0/libs/regex/doc/html/boost_regex/syntax… Boost.regex should also support that syntax, but it does not seem to work. For example: boost::regex_replace( std::string("xyyz"), boost::regex(".*(?<first>x)(?<second>y).*", boost::regex_constants::perl), std::string("$+{second}\\k<first>"), boost::match_default | boost::format_all | boost::match_extra); results in "yk<first>" This result shows that $+{second} evaluated to "y" but \k<first> evaluated to "k<first>". I thought maybe the \k<name> syntax was only supported as a backreference within the first regex instead of the replace string, but this doesn't work either: boost::regex_replace( std::string("xyyz"), boost::regex(".*(?<first>x)(?<second>y)\\k<second>.*", boost::regex_constants::perl), std::string("$+{second}"), boost::match_default | boost::format_all | boost::match_extra); The result is "xyyz" meaning nothing was replaced (the regex did not match). However, if modify the regex to use \\g{name} syntax, it works: boost::regex_replace( std::string("xyyz"), boost::regex(".*(?<first>x)(?<second>y)\\g{second}.*", boost::regex_constants::perl), std::string("$+{second}"), boost::match_default | boost::format_all | boost::match_extra); The result is "y". Am I doing something wrong or have I found a bug? I'm using the latest stable 1_44_0 release compiled from source in VC9 and I also tried the pre-compiled library (http://sourceforge.net/projects/boost/files/boost-binaries/1.44.0/libboost_…) The OS is Windows 7. Thanks for the help!

2 2

[Boost.Timer] Why timer doesn't have a specific windows version using QueryPerformanceCounter() and QueryPerformanceFrequency()?
by dlaugt＠free.fr 04 Nov '10

04 Nov '10

Hi, Boost.Timer is based on the C function clock(). On windows, this function gives a precision of 1 millisecond only as CLOCKS_PER_SEC is equal to 1000. Why Boost.Timer doesn't use for windows QueryPerformanceCounter() and QueryPerformanceFrequency()? These functions give a precision around 2 microseconds. Daniel.

3 2

[build][doc] Testing section and run rule
by Mateusz Loskot 04 Nov '10

04 Nov '10

Hi, I'm looking for reference about run rule and the only thing I can find is this short reference: http://www.boost.org/doc/tools/build/doc/html/bbv2/reference/rules.html pointing to the Testing section which is currently blank: http://www.boost.org/doc/tools/build/doc/html/bbv2/tutorial/testing.html Would there be any chance to get this part updated? I'm looking for details about the run rule arguments: rule run ( sources + : args * : input-files * : requirements * : target-name ? : default-build * ) I'd appreciate if someone could explain what is the differences: sources vs input-files or args vs input-files. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net Charter Member of OSGeo, http://osgeo.org Member of ACCU, http://accu.org

2 2

gcc-4.5.1 warnings (ISO C++ 1998 does not support ‘long long’)
by Neal Becker 03 Nov '10

03 Nov '10

boost-1.44.0 + gcc-4.5.1: Lots of these warnings ./boost/config/suffix.hpp:497:18: warning: ISO C++ 1998 does not support ‘long long’

2 1

Will 1.45 incorporate active regression tickets?
by Jim Bell 03 Nov '10

03 Nov '10

Will 1.45 incorporate active regression tickets? I.e., report {30} <https://svn.boost.org/trac/boost/report/30> Several of these could be incorporated without too much work. I think a scan of these would be worth the release managers' time.

3 9

Unicode Library
by Emery Denuccio 02 Nov '10

02 Nov '10

Hey guys, about three years ago I mentioned I was working on a unicode library for boost and there was some interest then. I guess professional work got in the way and I never got around to polishing it up and submitting for review. I was digging through an old hard drive and found the source. It still lacks a few features, but is pretty damn cool. I threw up on on github if anyone wants to take a look and possibly help me get rolling on it again. Here: http://github.com/imori/boost.unicode Thanks, -em

3 2

[chrono] review version
by vicente.botet 02 Nov '10

02 Nov '10

Hi, I have made some modifications to Boost.Chrono before the review (Version 0.7.0). 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… or in PDF format http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/chrono.pdf Boost.Chrono depends on Boost.Ratio http://www.boostpro.com/vault/index.php?action=downloadfile&filename=ratio.… and optionaly Boost.System Header Only http://www.boostpro.com/vault/index.php?action=downloadfile&filename=system…. Next follows the major changes: [*Features:] * Boost_Chrono is now a configurable header only lib that allows the user to choose in addition if the windows file is included or not. * Added clock_string<> traits. * Define chrono_io for all the clocks * Add input of process_times representation [*Implementation:] * Moved some details to static_integer directory. * Use of detail/win files to avoid the use of windows.h file. * Completed the error_code handling. * Works now with BOOST_SYSTEM_NO_DEPRECATED. [*Fixes:] * Fix some warnings. * Fix original error on Mac * Don't fix the link with boost_system to static. [*Test:] * Added test on process and thread clocks. * Moved to lightweight_test.hpp. * Able to test multiple configurations. [*Doc:] * Removed some not useful parts as the history, the test and the tickets. Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

2 2

[iostreams] Inconsistency of "faiture" of writes in Sinks and filters
by Artyom 02 Nov '10

02 Nov '10

Hello, I implement the sink device that sometimes may fail on writes. When Sink is implemented it should throw an exception on fault. To notify the stream on error. However it is not always works this way. I've got the exception to "leak" to the main program when I combine in the filter gzip_comressor() filter that writes to output device that its Sink is full. When I call reset on the filter the exception in leaking to the program instead of being caught. Is it bug or (accidental) feature? On the other hand, if I don't throw but rather return 0, I get into infinite loop in the boost::iostreams::non_blocking_adapter::write when I call filter.reset(). So I how can I write a sink device that reports errors? In following example the exception is caught when filter.reset() is called: #include <boost/iostreams/stream.hpp> #include <boost/iostreams/filtering_stream.hpp> #include <boost/iostreams/filter/gzip.hpp> #include <boost/iostreams/tee.hpp> #include <iostream> class my_small_device : public boost::iostreams::sink { int count; public: my_small_device() : count(1000) {} std::streamsize write(char const *d,std::streamsize n) { if(count < n) throw std::runtime_error("Device is full"); count-=n; return n; } }; int main() { try { using namespace boost::iostreams; boost::iostreams::stream<my_small_device> output(my_small_device(),10); { boost::iostreams::filtering_ostream filter; filter.push(gzip_compressor()); filter.push(output); for(int i=0;i<10000000;i++) { if(!(filter << i << '\n')) { std::cerr << "Fail!" << std::endl; break; } } std::cout << "Closing filter" << std::endl; filter.reset(); } std::cout << "ok" << std::endl; return 0; }catch(std::exception const &e) { std::cerr << "Catched " << e.what() << std::endl; return 1; } } Thanks, Artyom

1 2

Issues with intel's compiler and newer builds of GCC
by Bryce Lelbach 02 Nov '10

02 Nov '10

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 While working on getting icc to not choke on Serialization (the Boost test boxes indicated that icc was failing to build with the addition of my changes), I came across a very nasty bug the occurs when using icc with version 4.5 or higher of GNU's standard library - GNU's <iomanip> uses what are either illegal or C++0x semantics which icc doesn't support. Serialization uses <iomanip>, and icc seems to select the latest version of libstd++ installed on a Linux machine as it's default standard library (I have been unable to find an Intel standard library - I'm assuming such a thing doesn't exist). When using an older version of libstd++, icc + Serialization compiled fine. I removed all uses of IO parameterized manipulators in Serialization (there were only maybe half a dozen cases)*, and got icc to compile Serialization with libstd++ v4.5. Is there any chance the linux/darwin Intel build bots can be set up to use libstd++ v4.4, if they're not already using it? Intel is apparently aware of this issue, but it won't be fixed until their next major release (http://software.intel.com/en-us/forums/showthread.php?t=74691) If the build bots aren't using v4.5 of GNU's standard library, then I'm at a loss as to why Serialization is failing to build on them. My only other thought is that the timeout for the build cycle is too low - the failures indicate that the error is a timeout after 300 seconds. On a more general note, is Intel on Linux/Darwin a "supported" Boost compiler? Unless I've missed something, Intel doesn't provide a standard library, and I find it a bit troubling that they ship their compiler to use GNU's standard library by default. Intel is far behind GCC in C++0x support, and newer versions of the GNU standard library have been making increasing use of GCC's C++0x support. Unless icc starts shipping with an older version of libstd++/use a compiler neutral standard library such as the Apache standard library/starts to catch up with GCC's C++0x support, I imagine that using icc to compile C++ code that makes use of the standard library will become increasing difficult. * I also had to modify proto/debug.hpp to not use <iomanip>. Eric, when I was having an issue with typeinfo in proto/debug.hpp a couple days ago, you mentioned that proto/debug.hpp shouldn't be included by proto/proto.hpp? If that's accurate, is there any chance that change could be made, and if not, can I commit my changes to proto/debug.hpp or send them to you as a patch for review? - -- Bryce Lelbach aka wash http://groups.google.com/group/ariel_devel -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.9 (GNU/Linux) iEYEARECAAYFAky+c7cACgkQO/fqqIuE2t4DZQCfUnhGAsqX4GDZu3Ze7BvrPBRL XRkAn33vWcTm1RuXk2iuQWH0+bp+RVUf =mHwK -----END PGP SIGNATURE-----

7 9

[build_extensions][patch] General update and minor fixes
by Mateusz Loskot 02 Nov '10

02 Nov '10

Hi, First, I'm not sure if this is the right place to send patch to the build_extensions which live in the sandbox, I'm continuing to have complete build of Boost.GIL tests on Linux with 3rd-party dependencies configured using the build_extensions. It's trial and error process during which I've applied number of updates to .jam scripts for raster support libraries. The patch summary: zlib: added/removed .c source files jpeg: added/removed .c source files libtiff: - added missing tif_unix.c for <target-os>linux (not sure why <target-os>unix: could not kick in) - configure #define integral types required by tiffiop.h - added tiffxx target with C++ wrapper library (tif_stream.cxx) I have successfully used the extensions with the following libraries: jpeg-8a libpng-1.4.1 tiff-3.9.2 zlib-1.2.4 with GCC 4.4.5 on Linux 64-bit. I'm quite sure some of the changes could be mastered in much better way, but I lack of Boost.Build zen. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net Charter Member of OSGeo, http://osgeo.org Member of ACCU, http://accu.org

1 0

[gil][io_new] Problems with templates
by Christian Henning 01 Nov '10

01 Nov '10

Hi there, problems have been resolved. Thanks to everyone who tried helping! Regards, Christian

1 0

[range] - Proposal to change the indexed range adaptor
by Neil Groves 01 Nov '10

01 Nov '10

Fellow maintainers and developers, Having gained experience using the Boost.Range library changes I submitted for Boost 1.43, I have become dissatisfied with my indexed adaptor. Currently the underling index_iterator has a return type identical to the wrapped iterator, and the index is extracted via a method call on the iterator. While this works for the case where one is writing algorithms to explicitly utilise the underlying iterator, it is clearly a poor design choice since it severly limits the interoperation with other algorithms. I feel that I have made a mistake. I propose that a breaking change is made to the index range adaptor so that it returns a pair<original_reference_type, index_type>. How do you feel about this change? Do you have alternative suggestions? Regards, Neil Groves

5 7

boost::optional - rvalue references
by Daniel Larimer 01 Nov '10

01 Nov '10

I have been looking to optimize my code using rvalue references when they are supported; however, I currently use boost::optional which does not know how to handle / forward rvalue references. In fact even the in_place() utilities do not work to forward the rvalue into the proper constructor. My latest profiling shows that assigning a large vector to an optional is eating up 5% of my CPU time and I could replace this with a std::move() if boost::optional supported it. I have attached an updated optional.hpp with the minimum changes necessary to support the following: test v ( 99 ); test A ( 400 ); boost::optional<test> i2(std::move(v)); i2 = std::move(A); Such that if test were a vector and 99 and 400 were the sizes, the end result is v & A are of size 0 and i2 is of size 400 and no copy constructors are called (only moves). What is the plan for updating more of boost to take advantage of rvalue references?

2 1

Get PID from local socket?
by Rush Manbert 01 Nov '10

01 Nov '10

I am using boost ASIO to do socket communications between an app and a daemon running on the same machine. The communications go through a Unix Domain Socket on the Mac and a named pipe on Windows. I'm looking for a way that the client app could obtain the PID of the daemon process, starting with the connected socket. I have tried calling local_endpoint() and remote_endpoint(), but the only information there seems to be the socket path (at least on the Mac). My google searches have turned up nothing, and they actually suggest that there is no way to achieve this on the Mac, even if I were using the "normal" socket API. Does anyone know whether this is possible and how to do it? Thanks, Rush

2 1