- Boost - lists.boost.org

SafeInt library for Boost
by Omer Katz 12 May '09

12 May '09

Hi everyone, I am considering adding a safeInt library to Boost. If there are any suggestions regarding a special content of such a library, or any special implementation ideas, I'll be glad if you'd let me know. right now I plan to use a template class for it. I'll be glad to accept your comments. Regards, Ziv

1 0

structure alignment
by Christoph Macheiner 12 May '09

12 May '09

(Long-time reader, first-time poster) Hi all Recently I wanted to upgrade from 1.33 and got build errors in boost format. It is a quite large codebase which, for legacy reasons, has to be built with 1-byte structure alignment (this cannot easily be changed). The error comes from an boost::optional<boost::io::detail::locale_t> in boost/format/internal.hpp that wants to be 4-byte aligned (platform is Win32 vc9). Now I cannot just include this (or all) boost headers with 4- (or 8-)byte alignment because they include other std headers which have already been included before (with 1-byte alignment). Is there an easy solution to this that I am missing despite changing all includes? Is there information on such interdependencies somewhere? Or do I have to bite the bullet and include all standard headers with a suitable alignment. I am sorry if this has been discussed before, but I could not find anything. Thanks, Christoph.

1 0

[trac] version 1.39.0 in trac
by Michael Caisse 12 May '09

12 May '09

Version: Boost 1.39.0 needs to be added in trac for tickets. Thank you - Michael -- ---------------------------------- Michael Caisse Object Modeling Designs www.objectmodelingdesigns.com

3 2

Bounded String
by vicente.botet 12 May '09

12 May '09

Hi, I was looking for a bounded capacity string and I have take a look to the review (2006) of the rejected FixedString library (http://www.boostpro.com/vault/index.php?action=downloadfile&filename=fixed_…) Here follows a brief compilation of the main points * A motivating use case was missing * the motivating example (printf) was not enough significant, when we have the choice we can always find a better class. * The design was not adapted to the goals * the inheritance hierarchy was considered to complicated needing an allocation * buffer overrun should be configurable - truncate, exception, assert, * The formating should be considered orthogonal to the fixed_string class The context where I need to use something like this class is: * the binary layout can not be modified and must be bounded due to legacy issues, Third Party Products interfaces, protocol messages format or bounded capacity strings on persistent databases. * overrun must be checked because otherwise the program can crash. I will propose to name it bounded_c_string (when _c_ stands for "C-style" but recalls also capacity) These are the requirements I would associate to such a class * the value must always be a C-string (so with a trailing '\0') * The layout of a bounded_c_string<N> class must be the same as its counterpart C-string char[N] (sizeof(bounded_c_string<N>==N) * As a lot of code can use this type the refactoring from C code using char[N] to bounded_c_string<N> should be reduced to the type declaration (overloading of all the C string functions with bounded_c_string<N> are a must) * the efficiency must be equivalent to the hand written C-style * convertible to and from C-strings, std::string and other bounded_c_string<M> * C++ std::string like interface must also be provided Note that there is not issues with the length of the string coherency because not stored. This class do not intends to use dynamic memory when fixed capacity is not enough (see AutoBuffer library http://www.cs.aau.dk/~nesotto/boost/auto_buffer.zip for this use case) I don't know which is the FixedString library, the last upload on the Vault dates from 08.01.2006. Is there an interest for this simple class? Do you agree with the requirements? Is there an interest for a bounded_c_memory class which will take care of the length of the significant data instead of the trailing '\0'? Best regards, _____________________ Vicente Juan Botet Escribá

2 1

[GIL.IO] Looking for a review manager
by Christian Henning 12 May '09

12 May '09

Hi there, I'm looking for a review manager for the new GIL.IO extension. Anyone around here who would like to volunteer? Regards, Christian

1 0

Requesting interest in a bounded capacity C-string
by vicente.botet 12 May '09

12 May '09

Hi, I was looking for a bounded capacity string and I have take a look to the review (2006) of the rejected FixedString library (http://www.boostpro.com/vault/index.php?action=downloadfile&filename=fixed_…) Here follows a brief compilation of the main points * A motivating use case was missing * the motivating example (printf) was not enough significant, when we have the choice we can always find a better class. * The design was not adapted to the goals * the inheritance hierarchy was considered to complicated needing an allocation * buffer overrun should be configurable - truncate, exception, assert, * The formating should be considered orthogonal to the fixed_string class The context where I need to use something like this class is: * the binary layout can not be modified and must be bounded due to legacy issues, Third Party Products interfaces, protocol messages format or bounded capacity strings on persistent databases. * overrun must be checked because otherwise the program can crash. I will propose to name it bounded_c_string (when _c_ stands for "C-style" but recalls also capacity) These are the requirements I would associate to such a class * the value must always be a C-string (so with a trailing '\0') * The layout of a bounded_c_string<N> class must be the same as its counterpart C-string char[N] (sizeof(bounded_c_string<N>==N) * As a lot of code can use this type the refactoring from C code using char[N] to bounded_c_string<N> should be reduced to the type declaration (overloading of all the C string functions with bounded_c_string<N> are a must) * the efficiency must be equivalent to the hand written C-style * convertible to and from C-strings, std::string and other bounded_c_string<M> * C++ std::string like interface must also be provided Note that there is not issues with the length of the string coherency because not stored. This class do not intends to use dynamic memory when fixed capacity is not enough (see AutoBuffer library http://www.cs.aau.dk/~nesotto/boost/auto_buffer.zip for this use case) I don't know which is the FixedString library, the last upload on the Vault dates from 08.01.2006. Is there an interest for this simple class? Do you agree with the requirements? Is there an interest for a bounded_c_memory class which will take care of the length of the significant data instead of the trailing '\0'? Best regards, _____________________ Vicente Juan Botet Escribá

1 0

[filesystem] copy_file() not atomic proposed fix
by Beman Dawes 12 May '09

12 May '09

Ticket #2925 complains that "boost::filesystem cannot atomically copy file if target exists", and gives this example: void copy (std::string src, std::string target, int flags) { if ( (flags & Overwrite) && boost::fs::exists (tgt) ) { boost::fs::remove (tgt); } // second process can create file again here boost::fs::copy_file (src, tgt); } Changing boost::filesystem::copy_file() to overwrite isn't viable; (1) that just creates a mirror of the race condition when an overwrite is actually desired to be an error, and (2) changing the behavior would silently break existing code. The proposed solution is to add an option to copy_file(): enum class copy_option { fail_if_exists, overwrite_if_exists }; void copy_file( const Path & from_path, const Path & to_path, copy_option option=copy_option::fail_if_exists ); The implementation would be atomic on both POSIX and Windows. Comments? --Beman

1 0

Anybody tried AMD x86 Open64 Compiler Suite?
by Hartmut Kaiser 11 May '09

11 May '09

Here: http://developer.amd.com/CPU/OPEN64/Pages/default.aspx Regards Hartmut

4 3

[iostream] Device::read return inconsistency
by Richard Smith 11 May '09

11 May '09

The example in the documentation for the Source concept in Boost.Iostreams says: std::streamsize read(char* s, std::streamsize n) { // Read up to n characters from the input // sequence into the buffer s, returning // the number of characters read, or -1 // to indicate end-of-sequence. } (The same text appears in 'valid expressions / semantics' table, which is probably more definitive.) What does a return of less than n actually mean? Nowhere on the documentation pages for the Source concept or the read function template does it say what a return value in the range [0,n) means. And from the comment in the example, it would appear that read is permitted to return less than n if the some smaller number of characters are currently available /without/ implying that a subsequent call will hit eof. This seems to be confirmed by the use of non_blocking_adapter in places in the library where you want code to block until the n bytes are available, and to guarantee eof (or, I guess, an error) for a subsequent call. However, the comment in the BidirectionalDevice seems to disagree: std::streamsize read(char* s, std::streamsize n) { // Reads up to n characters from the input // sequence into the buffer s, returning the number // of characters read. Returning a value less than n // indicates end-of-sequence. } (Again, the same text appears in the 'valid expressions / semantics' table.) So which is it? I don't believe it is the library's intention for a [0,n) return to have different meanings in BidirectionalDevice and Source. I haven't located any code in the library itself that assumes a non-zero return of less than n signifies eof (though I haven't searched all that hard), but third-party code and/or any other boost libraries that use Boost.Iostreams may well do. However there do seem to be places where a return of zero is taken to mean eof. For example, indirect_streambuf::underflow seems to treat zero as eof. At the very least the documentation needs fixing to be consistent. And ideally it needs to document what a return of 0 means (presumably undefined behaviour unless n == 0) and whether a return in the range (0,n) implies that the next call to read will return eof (probably not). (Also, a minor typo: in the example on the Sink concept documentation, write should return std::streamsize, not void.) Richard Smith

2 3

[filesystem] [cygwin] Version 3 will not support BOOST_NO_STD_WSTRING
by Beman Dawes 11 May '09

11 May '09

The GCC 4.4.0 release binary for Windows available from http://www.equation.com/servlet/equation.cmd?call=fortran supports std::wstring, std::wcout, etc. Presumably official Cygwin support will follow. That removes the little remaining incentive I had, so Boost.Filesystem Version 3 will not support BOOST_NO_STD_WSTRING. There had been some previous discussion of this, but it is now definite. I still don't have an exact target date for V3, but plans should become more concrete over the next couple of months. --Beman

2 2