- Boost - lists.boost.org

[system][filesystem v3] Question about error_code arguments
by Beman Dawes 07 Nov '09

07 Nov '09

A POSIX sub-group is looking at C++ bindings for POSIX. They are talking about a filesystem library binding at least loosely based on Boost.System, Boost.Filesystem, and C++ TR2. In looking at http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2838.html, "Library Support for Hybrid Error Handling (Rev 2)", they are concerned about specifying hybrid error handling like this: void f(error_code& ec=throws()); They would rather see it specified like this: void f(error_code* ec=0); One particular concern is that as currently worded, the N2838 proposal requires throws() return a null reference, which they see as relying on undefined behavior. I wasn't at the meeting where the LWG asked that a null reference be mandated; my reading of the standard is that it is unclear if returning a null reference is or isn't undefined behavior. Some of the core folks seem to think it is undefined, but compilers accept it. Although the reference form is usual for C++, the use of anything other than the default is limited, and usually in low-level code at that. Although I could personally live with either form, I'm leaning slightly toward the pointer form. Regardless, I'd like to hear Boosters views on the two interfaces above. Which do you prefer? Why? --Beman

24 102

[wave][function] Suppressing gcc-4.4.1 warnings
by John Maddock 07 Nov '09

07 Nov '09

Looks like the new type-punning warnings from gcc-4.4.1 are false positives (but I'd like someone else to confirm that!). The fixes below illustrate how to suppress them simply by declaring a temporary variable. HTH, John. Index: boost/wave/util/flex_string.hpp =================================================================== --- boost/wave/util/flex_string.hpp (revision 57230) +++ boost/wave/util/flex_string.hpp (working copy) @@ -1211,7 +1211,10 @@ }; Storage& Data() const - { return *reinterpret_cast<Storage*>(buf_); } + { + Storage* p = reinterpret_cast<Storage*>(buf_); + return *p; + } RefCountType GetRefs() const { Index: boost/function/function_base.hpp =================================================================== --- boost/function/function_base.hpp (revision 57230) +++ boost/function/function_base.hpp (working copy) @@ -316,11 +316,13 @@ new ((void*)&out_buffer.data) functor_type(*in_functor); if (op == move_functor_tag) { - reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor(); + functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data); + f->~Functor(); } } else if (op == destroy_functor_tag) { // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. - reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor(); + functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data); + f->~Functor(); } else if (op == check_functor_type_tag) { const BOOST_FUNCTION_STD_NS::type_info& check_type = *out_buffer.type.type;

6 9

[Boost] Introduction of numeric_adaptor
by Bruno Lalande 07 Nov '09

07 Nov '09

Hi, I would like to introduce the numeric_adaptor library that Barend and I have developed to address a recurring problem: integration of big numbers. We already talked about it in the past, when discussions about geometry would lead to robustness. We're introducing it now because of the upcoming formal review of GGL. The purpose of this library is to turn big-numbers proposed by the most well-known big number libraries into value-types, (almost) usable like any number. This way, a library developer who has a robustness sensible function to write can take numbers as template parameters, and use them in such a way that they can be a fundamental type or one of the value-types provided by numeric_adaptor. This is basically done by: - defining in all the big-number types all the operators needed to manipulate them like fundamental types - defining some free functions in the boost namespace for other operations (sin, cos, hypot, conversions...), which have an default overload for fundamental types and a specific overload for each big-number type proposed Example: template <class T> T my_robustness_sensitive_function(T value) { value /= 2; T value2 = boost::to<T>("123.0123456789"); value += boost::sqrt(value2); return value; }; This function is numeric_adaptor-ready. If T is a fundamental type, boost::to() will forward to boost::lexical_cast and boost::sqrt() will forward to std::sqrt(). If T is one of the big number types provided by the library, specific overloads will be used. The precision of the function will thus entirely depend on the type passed. If the user chooses to sacrifice precision and use fundamental types, there won't be any run-time overhead. If the user wants something more precise and uses a big-number type, the precision of the result will be the one of the chosen type. The library is extensible. Anyone can add a new big number type with all needed operators, and overload the free functions (or specialize a dedicated traits class - see boost::to()). Note: For conversions, we would have liked to extend boost::lexical_cast directly, but the library is not designed in that sense. That's why we wrapped it into a boost::to() function which is explicitly designed to be extended, via traits. Last week on this list list a generic convert_to was discussed and that system could be used alternatively. The library is in the Boost sandbox: https://svn.boost.org/svn/boost/sandbox/numeric_adaptor/ The library currently proposes 2 big number types: CLN and GMP. This is not a formal review request, rather a preview and a reference that we will possibly use during the review of GGL. However, we would really like to have your feedback and to know if such a library would make sense. Regards Bruno

7 13

boost::noncopyable errors are difficult to diagnose on MSVC
by Zachary Turner 07 Nov '09

07 Nov '09

Is there anything that can be done to improve the error messages generated by the compiler when a copy fails to be made due to a boost::noncopyable? I had just finished a sprint where I had typed close to 1,000 lines of code with tons of new classes and objects before trying to compile, and one of the classes I had entered was similar to the following: class foo { public: foo(boost::asio::ip::tcp::socket& socket) : socket_(socket) { } private: boost::asio::ip::tcp::socket socket_; }; Problem here is that I forgot to add a reference to the class member, it was by value so the compiler is going to generate an error since a socket cannot be copied. The error this generated from the compiler was: 1>Q:\include\boost\1.39.0\boost/asio/basic_io_object.hpp(92) : error C2248: 'boost::noncopyable_::noncopyable::noncopyable' : cannot access private member declared in class 'boost::noncopyable_::noncopyable' 1> Q:\include\boost\1.39.0\boost/noncopyable.hpp(27) : see declaration of 'boost::noncopyable_::noncopyable::noncopyable' 1> Q:\include\boost\1.39.0\boost/noncopyable.hpp(22) : see declaration of 'boost::noncopyable_::noncopyable' 1> This diagnostic occurred in the compiler generated function 'boost::asio::basic_io_object<IoObjectService>::basic_io_object(const boost::asio::basic_io_object<IoObjectService> &)' 1> with 1> [ 1> IoObjectService=boost::asio::stream_socket_service<boost::asio::ip::tcp> 1> ] The most I can possibly figure out from this is that it's related to a socket. but this hardly helped as I had been using socket stuff all over the place. It took a long time to track this down because there was zero information about even what source file the offending code was in. I know this is sort of catering to the compiler, but is there any trickery that can be done so that at least the compiler generates an error related to the source file the object was declared in?

4 4

ASIO
by Mohammed Rasmy 07 Nov '09

07 Nov '09

Hello, I am trying to do a POST request using Boost::Asio, of a variable x that holds an email address, and a variable y that holds the contents of a zip file. I couldn't find samples floating around and I'm unsure of how to proceed. I've come up with the following code: boost::asio::streambuf request; std::ostream request_stream(&request); wxString buffer = wxT("POST "); buffer += wxT("http://serveraddress.com"); buffer += wxT(" HTTP/1.1\r\n"); buffer += wxT("Host: serveraddress.com\r\n"); buffer += wxT("Accept: */*\r\n"); buffer += wxT("Connection: close\r\n\r\n"); buffer += wxT("email_address=test(a)test.com"); buffer += wxT("zip_file=")/*actual zip file data here?*/; request_stream << buffer.mb_str(); Note that I am using wxWidgets, wxT is nothing more than a way of defining strings there, and wxString is, well, a string. The above code compiles fine, but I am not sure how to add the zip file? Also would the above code work? I know it is working for a GET request but that's it. Please advise. Thanks for your time, Mohammed _________________________________________________________________ Keep your friends updated—even when you’re not signed in. http://www.microsoft.com/middleeast/windows/windowslive/see-it-in-action/so…

4 4

[smart_ptr] Add make/allocate functions for boost::shared_array
by Roman Kecher 06 Nov '09

06 Nov '09

Hi, I was wondering if there's any reason not to include make_shared_array() / allocate_shared_array() in boost/make_shared.hpp (or maybe add boost/make_shared_array.hpp), along with the already existing make_shared() and allocate_shared() functions? Regards, Roman.

1 0

[swap] ruminations
by Jeffrey Hellrung 06 Nov '09

06 Nov '09

1) Would it be a good idea (aside from breaking backwards compatibility) to insulate boost::swap from being found via ADL? Consider another library, tsoob, which also has a swap intended to be used in the same manner as boost::swap (i.e., it finds a free function swap via ADL, falling back to std::swap or maybe some custom swap or whatever). Now tsoob::swap and boost::swap cannot be used in the same program (ambiguous call to overloaded function swap) if the associated namespaces of the type being swapped includes both boost and tsoob (certainly possible). What I'm thinking about is the possibility of creating a namespace boost::adl which contains (what would have previously been called) boost::swap, as well as any other similar free functions. So the only way to invoke boost::adl::swap is to make it explicit; it will never be found via ADL. Plus it helps document the underlying mechanism (ADL) of boost::swap. 2) Is there some way for boost::swap and tsoob::swap to coexist peacefully while retaining backwards compatibility for both? - Jeff

2 3

[graph] Usage (and possible removal) of LEDA and Stanford GraphBase adaptors for Boost.Graph
by Jeremiah Willcock 06 Nov '09

06 Nov '09

Are there any users of the LEDA and Stanford GraphBase adaptors for Boost.Graph? They are no longer actively maintained and there have been bug reports that the LEDA adaptor does not work with current versions of LEDA. If they are no longer used, Andrew Sutton and I will consider deprecating and/or removing them. Please reply if you would like these components kept in Boost.Graph. -- Jeremiah Willcock

1 0

[random] Seeding again
by Steven Watanabe 06 Nov '09

06 Nov '09

AMDG The attached patch allows random number generators to be seeded with any value. Currently linear_congruential and a few other generators can assert for some seeds. (For instance minstd_rand cannot be seeded with 0). For linear_congruential I am using the algorithm described in n2960, section 26.5.3.1/4. For linear_feedback_shift I use a similar idea, adding 2^(w-k) if the seed is less than 2^(w-k). The behavior of any code that was valid before, should be unaffected by this change. The patch includes test and documentation updates. The tests pass with gcc, msvc, and como. I think it's ready to go now. Okay to commit? In Christ, Steven Watanabe

1 0

New boost packaging suggestion for windows
by Julian Bangert 06 Nov '09

06 Nov '09

Hello, yesterday I tried to download the boostpro binaries for windows and I had to download over a gigabyte to get all configurations for VS 2008. Sadly the version also was outdated and in general not that great ( e.g. Installer quite bad to handle and you have to register to download ) . So I decided to build from source and package it for a few friends who also needed these binaries. I managed to compress boost_1_40 ( no source except headers, no python AFAIK , but everything else you get with a standard build ) from over 900MB down to 37MB by using 7z. I uploaded it here https://obliviononline.com/pub/boost/boost_1_40_0.7z . Should boost use this form of releasing binaries in the future for windows ? Alternatively, you could endorse this form, like boostpro is endorsed right now and I could host it on google code, etc . An easy to set up ( just unzip this file ) binary distribution would make compiling boost-dependent software much easier. I would be willing to distribute future releases compatible with VS 2005 and 2008 in this form. Yours, Julian Bangert __________ Information from ESET NOD32 Antivirus, version of virus signature database 4551 (20091028) __________ The message was checked by ESET NOD32 Antivirus. http://www.eset.com

12 20