- Boost - lists.preview.boost.org

A question about Units & Spirit
by John Phillips 15 Jun '09

15 Jun '09

In the middle of the directX thread, Daniel Duffy asked a question that seems more suited to its own thread. I'm starting that thread and giving others a chance to join into the discussion by giving you the content of the few messages that have passed by so far. John From Daniel --------------------------------------------------- Hello, This is my first mail, so I hope I have sent it to the right address :) I am using the Units library for Dimensional Analysis. So far it is very useful. Up till now I am using it in a hard-coded/compile time way as in a test.cpp. My inteterst is in using Units as part of a larger run-time system so I need some way of making my code more flexible. Lambda library is an option here but I would also like to create units and quanties from string input as well as being able to parse these strings to units and then store the units in a database. Can I use Spirit (and Serialization) for these features? Maybe the functionality already exist, and I have not found it. best regrads Daniel J. Duffy From Hartmut --------------------------------------------------- Sure Spirit is your friend for all parsing and output generation needs. What did you have in mind? Regards Hartmut From Daniel ---------------------------------------------------- Hartmut, I would like to generate well-formed units and create expressions of the followiong kinds: Examples of unit expressions: 1. 2m + 15m*32s/16s = 32m. 2. 3m*7s + 2m*10s/5m = 21m + 4s -> ERROR. Can't add meters to seconds. The second group looks more tricky. Examples of simplification: 1. (x-2)2 + 4x2 - 2^x + 1 = 5x2 - 8x + 10 2. x2 + 7x + 10 = (x + 2)(x + 5) 3. (a + b)(a - b) = a2 - b2 4. sin(x)2 + cos(x)2 = 1 5. 2sin(x)cos(x) = sin(2x) One tricky part is for example #5 where the code needs to 'know' trigonometry. best regards Daniel From John ---------------------------------------------------------- Daniel J. Duffy wrote: > Hartmut, > I would like to generate well-formed units and create expressions of the followiong kinds: > > Examples of unit expressions: 1. 2m + 15m*32s/16s = 32m. 2. 3m*7s + 2m*10s/5m = 21m + 4s -> ERROR. Can't add meters to seconds. So, you want this to happen at run time, or at compile time? At compile time, I think you are already set with the Units library. At run time, there are examples with the library that would help. If parsing the input is your concern, then Spirit is a good choice. (Spirit 2 is even better, by the way.) Using the two together, you could write a program where a user enters your example lines and gets correct responses. > > The second group looks more tricky. > > Examples of simplification: 1. (x-2)2 + 4x2 - 2^x + 1 = 5x2 - 8x + 10 2. x2 + 7x + 10 = (x + 2)(x + 5) 3. (a + b)(a - b) = a2 - b2 4. sin(x)2 + cos(x)2 = 1 5. 2sin(x)cos(x) = sin(2x) > One tricky part is for example #5 where the code needs to 'know' trigonometry. As far as I can tell here, you are looking for a program that does symbolic algebra. If that is true, then I don't think boost has a complete solution for you. Writing the parser for the input with Spirit wouldn't be that bad, but writing the processing engine that matches patterns and does simplifications is not covered by any current Boost libraries. I don't recall seeing anyone poll for interest on this, so I don't think there is even a partial library in the sandbox. Would you want this at run time, compile time, both? I haven't tried to write it, but I think a pure compile time implementation would be prohibitively slow. For a pure run time solution, you might consider linking to already existing solutions, such as Maple or Mathematica. > > best regards > > Daniel > John

2 2

[ptr_container] Can't store a pointer to const in multimap?
by Amit Kumar 15 Jun '09

15 Jun '09

Please consider the following code: #include "boost/ptr_container/ptr_map.hpp" int main() { typedef boost::ptr_multimap<char, const int> M; M m; char c = 'c'; int* j = new int(7); m.insert(c, j); return 0; } The gcc 4.3.3 compiler fails to compiler the above code. Am I doing something wrong by inserting a non-const? Can't I store a pointer to const in the multimap? try.cpp: In function ‘int main()’: try.cpp:8: error: expected primary-expression before ‘=’ token /usr/include/c++/4.3/bits/stl_pair.h: In constructor ‘std::pair<_T1, _T2>::pair(const std::pair<_U1, _U2>&) [with _U1 = char, _U2 = const int*, _T1 = const char, _T2 = void*]’: boost/boost_1_39_0/boost/ptr_container/ptr_map_adapter.hpp:765: instantiated from ‘typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::iterator boost::ptr_multimap_adapter<T, VoidPtrMultiMap, CloneAllocator, Ordered>::insert_impl(const typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::key_type&, typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::mapped_type) [with T = const int, VoidPtrMultiMap = std::multimap<char, void*, std::less<char>, std::allocator<std::pair<const char, void*> > >, CloneAllocator = boost::heap_clone_allocator, bool Ordered = true]’ boost/boost_1_39_0/boost/ptr_container/ptr_map_adapter.hpp:799: instantiated from ‘typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::iterator boost::ptr_multimap_adapter<T, VoidPtrMultiMap, CloneAllocator, Ordered>::insert(typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::key_type&, typename boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator, Ordered>::mapped_type) [with T = const int, VoidPtrMultiMap = std::multimap<char, void*, std::less<char>, std::allocator<std::pair<const char, void*> > >, CloneAllocator = boost::heap_clone_allocator, bool Ordered = true]’ try.cpp:9: instantiated from here /usr/include/c++/4.3/bits/stl_pair.h:106: error: invalid conversion from ‘const void*’ to ‘void*’ I also tried but failed with const casting j before insertion.

3 2

[serialization][trunk] Latest patch for void_cast.cpp causes segfaults
by Hartmut Kaiser 15 Jun '09

15 Jun '09

Hi all, apparently the latest patch to boost/libs/serialization/src/void_cast.cpp (rev.53078, svn:date: 2009-05-18T06:25:56.023190Z, svn:author: ramey, svn:log: fix errors in extended_type_info management) causes an existing application to segfault during cleanup. The application was working properly before. The attached patch fixes the issue. Ok to commit? Regards Hartmut

1 0

Removing Bind placeholders from the global namespace
by Peter Dimov 15 Jun '09

15 Jun '09

This topic has again come up recently in boost-users. I have already assigned myself a ticket, https://svn.boost.org/trac/boost/ticket/2240 but have done nothing so far, in part because it would break other Boost libraries. (Patching placeholders.hpp is trivial in itself.) This is one case in which the trunk/release procedures don't work well as-is unless someone volunteers to produce a patch against all of Boost that at once moves the placeholders into namespace boost::placeholders _and_ fixes all errors that this would cause. It'd be easier to split the work: I put the breaking change in and then the libraries are fixed one by one. :-) Comments? -- Peter Dimov http://www.pdplayer.com

10 31

[candidate bloom_filter] nitpick
by JOAQUIN M. LOPEZ MUÑOZ 15 Jun '09

15 Jun '09

Hi Michael, I see that internals.hpp declares the following: namespace boost { namespace detail { template <class Input, class BitSet> class bloom_filter_internals {...}; } } boost::detail should not be used for internals of a specific library. The custom is to do it like this: namespace boost{ namespace bloom_filters{ namespace detail{ // you might want to rename to just "internals" // as the qualified name is sufficiently informative template <class Input, class BitSet> class bloom_filter_internals {...}; } } } Note the "s" in "bloom_filters", following the naming guidelines at: http://www.boost.org/development/requirements.html#Naming_consistency Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

2 2

Boost and XML-RPC
by Dmitriy Lyfar 15 Jun '09

15 Jun '09

Hello boosters, What do you think about boost.xmlrpc implementation? Some days ago I need simple xmlrpc library with https support, but I cannot find anything for windows. What I've found it's http://libiqxmlrpc.sourceforge.net/ library. But it has too many dependencies, I really don't understand why I should compile half of gnome to have an ability call xmlrpc methods. So after some libs I realized that there is no good xmlrpc lib for windows at least (if you know, please let me know). So what are you thoughs about implementation such lib as part of boost (asio based for example)? Is it needed for community? Thank you, Dmitriy.

2 3

Blechmann's lock-free
by Michael Caisse 14 Jun '09

14 Jun '09

Tim - I just downloaded your lock-free data structure code and was getting ready to take a look at it. Two questions immediately come to my mind: 1. What is your intent for this library? Do you plan on having it reviewed? 2. Do you have pre-made docs available somewhere? I seem to consistently have troubles getting the doc chain going. Best Regards - michael -- ---------------------------------- Michael Caisse Object Modeling Designs www.objectmodelingdesigns.com

2 1

[date_time] Change to the time_duration default format.
by Ilya Bobir 14 Jun '09

14 Jun '09

Hi all, I would like to propose a change to the default format for the time_duration objects. Current format is "%H:%M:%S%f". It does not allow one to input a time_duration that is longer than 99 hours. My proposal is to change the format to be "%O:%M:%S%f". time_duration objects are not restricted to 99 hours so the current behavior seems to be incorrect. I have submitted a patch but was told that the change is a braking change and need to be discussed on a mailing list: https://svn.boost.org/trac/boost/ticket/1861#comment:3 Please reply if you think there could be issues with the change to the default time_duration format. Here is a simple test that shows what I'm talking about: #include <iostream> #include <sstream> #include <boost/date_time.hpp> using namespace std; using namespace boost::posix_time; int main(void) { time_input_facet* facet = new time_input_facet(); locale loc(locale(locale(), facet)); time_duration td1(hours(100)); time_duration td2; stringstream ss; ss.imbue(loc); /* Input using default time_duration format. */ facet->time_duration_format("%H:%M:%S%f"); ss << td1; ss >> td2; cout << td2 << endl; /* Input using proposed time_duration format. */ ss.str(""); ss.clear(); facet->time_duration_format("%O:%M:%S%f"); ss << td1; ss >> td2; cout << td2 << endl; } For me it outputs: 00:00:00 100:00:00 It means that you can not serialize and deserialize arbitrary time_duration objects if you are using the default format. While the output facet do write extra digits the input facet will accept only two digits for the hours field. Ilya Bobir

2 1

Re: [boost] first review submission of timer_queue.zip
by JohnQ 14 Jun '09

14 Jun '09

>> Thanks to any who take the time to review this and help me make it better. > >Why the call_back is associated to the timer_queue and not to the timeout? If I understand your question correctly, it's because this allows me to look at a "window" of time when the current timer expires. That way I can call the callback multiple times for timers that are all within the current "window" to avoid invoking context switches for each of those timers. > >Do we really need several timer queues? Shouldn't only one be enough? IMO the class timer_queue >muts be hiden to the user. The interface I would like to use is something like, > > auto h = after_call(miliseconds(10), f, x, y); >or > auto h = at_call(now()+miliseconds(10), f, x, y); > > if (some condition) { > h.interrupt(); > } Let me take a closer look at this and make another reply... I'm short on time right now... but I have a question about the first part... there should only be one timer queue... and actually the container behind the scenes is a multi-index map (not really a queue). > >The user should be also able to wait until the timeout has expired and the function called. So > > h.wait() > >will synchronize with the end of the function call f(x,y). If in addition f returns something the >following should also be correct > > auto res = h.get() > >So the handle returned by > auto h = after_call(miliseconds(10), f, x, y); > >must implement the future interface (an asynchronous completion token). I think I agree... but need more time to go through your suggestion. > >There are classic implementation using a well instead of a queue which make insertion independent >of the number of active timers (see for example "Redesigning >the BSD Callout and Timer Facilities" by Adam M. Costello, George Varghese > http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=B5202FC949FF3EDB0E… ). > Yes, this is good advice... I'll take a look. >Best regards, >Vicente Excellent ! Thanks for giving this a detailed look Vicente. ----- From Dmitry---- >>>> What mechanism do you use to suspend till it's time to fire a callback? >>>> >> >> boost::condition_variable m_timed_cond.timed_wait(timer_lock, cur_timer) >> >> >This approach has a drawback. After the timeout expires timed_wait() has >to lock a mutex. And this can take arbitrary long. >Especially if there are other threads that are waiting for the same >mutex. Any thread that came before your thread will, most probably, >acquire the mutex before your thread. >This obviously spoils precision. Why dont you use a semaphore instead? >In order to improve precision, the library can also wait a bit less than >the client asked to give the thread some time to resume. Under high load >the scheduler can give your thread the processor long later than you asked. Thanks Dmity! As with my answers to Vicente above, let me take a closer look and reply. I've been completely swamped, the last 1-2 weeks and I'm just coming out of it. :) Thanks, John Q.

1 0

[PropertyTree] Rewrite - Please Review
by Sebastian Redl 13 Jun '09

13 Jun '09

Hi PropertyTree users, I have completed the main bulk of the property tree rewrite/cleanup. In the course of this, I have made the code standard-compliant (it previously used a std::list of an incomplete type, which is not, strictly speaking, valid), made it follow the claimed complexities (find() was O(n), although the docs said it's O(log n)), and revised the customization interface quite thoroughly. Inevitably, there were breaking changes in this process. I would ask everyone who has existing code using PropertyTree to look at these changes and tell me their best guess at how much effort it would be to update the code to conform with the new interface, and how I could make this easier. The development is still in a branch, so you need to check out the SVN branch http://svn.boost.org/svn/boost/branches/sredl_2009_05_proptree_update to try out the new version. The breaking changes are as follows: 1) Probably the most common change need: ptree::find() now returns the new type assoc_iterator (const_assoc_iterator for the const version) instead of iterator (const_iterator). This means that you need to change the type of the variable you capture the result with to assoc_iterator. It also means you need to compare the result of find() against ptree::not_found() instead of ptree::end(). You can get an iterator from an assoc_iterator by passing it to ptree::to_iterator(). The other projection direction is currently not supported, although it would be trivial to add. 2) The number and order of template arguments to basic_ptree has been changed. The old arguments were * Key comparison predicate * Key type * Path type * Data type * Translator type The new arguments are * Key type * Data type * Key comparison predicate (defaults to std::less<Key>) The old order prevented defaulting and wasn't very useful in general. The new order is consistent with std::map. The path and translator arguments have been removed to simplify the interface of basic_ptree. Equivalent functionality is available (see below). If you used your own instantiation of basic_ptree before, instead of simply using the (wi)ptree typedefs, you will have to adapt your code to the new order. If you used custom path and/or translator types, read on. 3) put and put_child previously had a final parameter 'bool do_not_replace'. I don't like boolean parameters, especially those whose name contains a negation. I removed the parameter, and replaced its functionality by a pair of new functions, add and add_child. If you previously called put or put_child passing true for do_not_replace, you must change these calls to add or add_child, respectively. If you ever passed false explicitly, you have to remove this parameter. 4) Using custom path types has changed. You can no longer create individual basic_ptree instantiations with custom path types. Instead, a key type has a fixed path type associated with it. I can bring this functionality back pretty easily if required, but I want to see use cases for this first. (Such things are why I make this call for reviews.) Less template parameters to ptree is good, in my opinion. To use a key type other than std::basic_string specializations, you have to specialize boost::property_tree::path_of for this key type. The path_of struct contains a single type called type, which is the path to use for this key type. The way paths are implemented has also changed thoroughly. Previously, you had to implement a const and a non-const variant of get_child, plus put_child (with do_not_replace making that effectively two functions too). These functions contained a lot of logic that really belonged into ptree, making implementing custom paths tedious and error-prone. The new interface requires you to implement four functions, but they're far simpler. The functions are described in ptree_fwd.hpp in C++0x concept syntax, but here's the gist: bool path::empty() const -> is the path empty? bool path::single() const -> does the path contain a single element? key_type path::reduce() -> chop off the first part of this path and return it (basically a pop_front that returns the value). std::string dump() const -> get a readable form of this path for exception messages; feel free to return "" here if you don't care. The new interface should be easy to implement, and the tree traversal is now where it belongs (in the internal implementation functions walk_path and force_path). 5) Using custom translators has changed. A ptree no longer has a fixed translator associated with it. Instead, you can supply a custom translator to every get_value/get/put_value/put operation or use the default, which depends on the tree's data type and the type you extract/insert. An example: ptree pt; pt.put("k1.k2", 100); // Uses the default translator for std::string+int. // Note: the explicit template parameter here will go away. float f = pt.get<float>("k1.k2", my_special_float_string_converter()); The tree's own data type is called the internal type, while the parameter/return type is called the external type. The default translator for a internal+external pair is set by specializing the boost::property_tree::translator_between struct. By default, PropertyTree supplies an id_translator for when the internal and external types are the same, and a stream_translator for converting between a basic_string and anything else. Together, they faithfully emulate the behavior of the old default translator. Writing a custom translator is easy. It's a class that provides two typedefs and two functions: typename internal_type -> the internal data type typename external_type -> the external data type optional<external_type> Tr::get_value(internal_type) -> convert from the internal to the external type, boost::none on failure optional<internal_type> Tr::put_value(external_type) -> convert from the external to the internal type, boost::none on failure That's it for the changes. The new version of property tree is not quite complete yet. I still need to polish the documentation a little and document the new extension mechanisms properly. I also need to clean up a little. Finally, the INI parser doesn't work at the moment. However, the main functionality (tested by property_tree_test) plus the XML, JSON and INFO parsers should all work now. Looking forward to your feedback. Sebastian

3 4

[lexical_cast] Volunteer testers needed
by Adam Badura 13 Jun '09

13 Jun '09

The attached file contains a modification to lexical_cast which I want to be included in Boost 1.40. However that requires testing since lexical_cast is widely used. I did my own tests but it is not enough. Thus I ask anyone willing to volunteer to use the attached code and notify about the result. The attached file should be used instead of Boost's lexical_cast. It adds boost::classic_lexical_cast which acts exactly as boost::lexical_cast with std::locale::classic as the global locale. Two things have to be tested. 1) [more important] Whether boost::lexical_cast works as previously after the changes. 2) [less important] Whether boost::classic_lexical_cast works as expected. The changes allow to use lexical_cast in locale-independent tasks (like serialization of data) through the boost::classic_lexical_cast in applications which set global locale to something else then the classic locale. Also having those changes easies possible addition of text-based conversion function talking arbitrary locale object. Thanks in advance to anyone who helps. Adam Badura

2 2

Doxygen and Boostbook
by Mathias Gaunard 13 Jun '09

13 Jun '09

While looking at the Boostbook documentation, I couldn't find documentation about how Doxygen documentation is transformed into Boostbook. I think documentation that says how one doxygen special block is transformed to a boostbook element would be useful, as well as how to generate boostbook elements from special blocks not supported by doxygen. For example, I don't know how to define concepts in Doxygen. Is such documentation available somewhere?

1 0

Performance of boost::mutex and boost::mutex::scoped_lock
by Zachary Turner 13 Jun '09

13 Jun '09

I have been doing some profiling using VTune recently to investigate the cause of some underperforming multi-threaded code, and it's possible that I'm not interpreting these results correctly, but if I am it's a little surprising. This isn't the best multi-threaded design in the world, but it's basically a naive implementation of a producer consumer that uses a deque as the production queue, a boost::mutex as the lock, and a boost::condition as a signal to wake up when there's stuff in the queue (queue comment about boost::circular_buffer, which this code really should be using instead). There is LOTS of context switching going on, basically I read a 4KB chunk of data from the filesystem, put it in the queue, the other threads takes the 4KB of data, does something with it, and this repeats for a really long time. Since it doesn't take a whole lot of time to read 4KB of data from the disk, you can tell that there are going to be zillions of context switches and contention going on. So on to the point. Obviously most of the time is spent in boost::detail::basic_timed_mutex::lock, but what's surprising is the breakdown of time inside the lock function: (Keep in mind this is not timed over a terribly long sample, hence the small numbers, but it is over thousands of actual locks, and ultimately this locking alone makes up a noticeable portion of the sample duration) boost::detail::basic_timed_mutex.lock Total Time: 1,032,486 microseconds (1.032 seconds) Total Wait Time: 505,884 microseconds (.505 seconds) It appears that only half the time is actually spent inside the lock, which is pretty crazy. The rest is spent doing computations, which doesn't seem right for a lock. I drilled down further and came up with this: boost::detail.get_system_time_sentinel Total Time: 266,657 microseconds Total Wait Time: 264 microseconds So that accounts for about half of the computational time. The rest is in a Windows system call somewhere that I was not able to drill into. I don't know about the details of date_time library, or much about the details of thread library either for that matter, but why is a time necessary here at all? This is eventually resolving down to a boost::detail::basic_timed_mutex, but there's nothing timed about the operations I've done. I simply did the following: boost::mutex m; boost::mutex::scoped_lock lock(m); //... This should ultimately result in an infinite timeout being specified to the system call, so all of this computation seems completely unnecessary. It seems like a scoped_lock should completely bypass anything having to do with date_time, and perhaps even normal timed locks should come up with a more efficient strategy. Thoughts?

4 4

[mpl] mpl::string, ok to merge to release?
by Eric Niebler 13 Jun '09

13 Jun '09

The mpl::string tests look OK to me on trunk, so I was planning on merging this to release for 1.40. Objections? Aleksey, I've had some problems generating the refmanual html from the rst source. It seems to go OK, but then some of the internal links are broken, and I can't figure what I'm doing wrong. Could you generate new html from the rst on trunk and commit it back to trunk? Please let me know the revision number after you do, and I'll merge it all to release in one go. Thanks. -- Eric Niebler BoostPro Computing http://www.boostpro.com

2 3

Re: [boost] boost::directx?
by Kasra 13 Jun '09

13 Jun '09

Hi guys, I have been following this thread but haven't really found the significance of boost::directx! If the purpose of the library is to create a comprehensive graphics library, choosing directx or infact any other API seems absurd. For example, ORGE is a graphics library that doesn't choose OpenGL over DirecX but provides a wrapping interface for a graphics library where this library's internal is OpenGL and DirectX depending on the platform. I just think if this library is going to established within boost, it requires a portable interface irrespective of the internals. With Best Regards --- Kasra Nassiri

16 41

Why the integration branchmust remain clean, etc.
by David Abrahams 12 Jun '09

12 Jun '09

I just realized I can articulate what's not working for me about the current trunk/release branch arrangement. * IIUC, there are always lots of failures on the trunk because there's no pressure to keep it clean. * Before I check in a change in one of my libraries, I want to make sure I haven't broken anything else in boost. So naturally, I run the whole regression suite (there oughta be a better way!) * But since the trunk is not clean, I spend a lot of time analyzing problems that have nothing to do with my library. That's a real disincentive to making changes in Boost. In fact, I am confident my low activity in the repo over the last year or so is primarily caused by the amount of labor associated with testing my changes. Now, maybe you'll suggest that I test my own library, then damn the torpedoes and check in the changes, and let other people complain to me when their libraries break. That would work... except that many people aren't paying attention to the health of their libraries on the trunk. I suppose another approach might be to test against the release branch, then svn switch to the trunk and check in my changes there. But that is still laborious. I'm not sure what to do about this, but it's really killin' me. -- Dave Abrahams BoostPro Computing http://www.boostpro.com

5 10

Some good news for boost
by David Abrahams 12 Jun '09

12 Jun '09

Apparently we've been selected as an "alternate finalist" in the SourceForge Community Choice awards! They want us to answer some questions and provide some supporting material. If anyone else in the community would like to contribute to answering questions 1 and 2 below, that would be awesome. Marshall, you're the only person I know of that has any Boost-related video. What do you think about #4? -- Dave Abrahams BoostPro Computing http://www.boostpro.com

5 5

Documentation Edits
by Zachary Turner 12 Jun '09

12 Jun '09

What is the standard protocol for editing documentation? It doesn't appear to be a wiki, unless you have to explicitly request write access in which I wasn't aware of that. The reason I ask is that there are many times where I've spent forever toiling over the documentation of some new library that I wasn't familiar with, because the documentation either provided no / insufficient samples, functions with very general names and one-liner documentation that says (for example) "runs the service". Which is pretty obvious when the function is called run, but no mention of the implications or what "running" even means. Other examples include lack of discussion over memory ownership (I spent 6 hours yesterday trying to trace down a memory corruption only to later find that in one of the many example programs for the library a single line comment that said "this causes X to take ownership of Y". If that had been in the documentation I would have spent 5 minutes tracing down the bug. So my point in all this is can the documentation be in wiki format, and as a fallback is there a way that someone other than a library owner/maintainer can edit it?

2 1

Re: [boost] Possible problem: Christian Schladetsch
by John Maddock 12 Jun '09

12 Jun '09

> Let's not turn an accidental mailing into a tar and feather. All things > said and done, he is at least attempting to contribute something to the > community. Indeed, can we please consider this thread closed now, Thanks, John Maddock. Boost Moderator.

1 0

1.40.0 showstoppers
by Vladimir Prus 12 Jun '09

12 Jun '09

During last release cycle, we talked that there should be a way to flag some issues as showstoppers for next release, so that next release is either delayed until the issue is fixed, or the issue is explicitly downgraded by the release team after consideration. However, I am not sure we've reached definitive agreement on how such issues should be marked. One proposal is to use the 'showstopper' status. Does that sound OK to our release managers? If so, shall this convention be documented somewhere, and should release procedures be adjusted to including checking this list prior to rolling betas and final release? I can do the necessary edits if everybod agrees, and tell me what to edit. Thanks, Volodya

1 0

Re: [boost] "boost cold shoulder" (was proposal for #pragmaonce support)
by Brian Wood 11 Jun '09

11 Jun '09

Sid Sacek writes: > I believe I belong to a third category that you didn't mention below: > 3. The middle-aged mellowed-out "try to always do the right thing", > "using namespace boost", crowd. I don't think doing the right thing implies automatically using a Boost library, but rather considering the options. I encourage people to "chew the meat and spit the bones" when it comes to Boost. Some of the libs are very helpful and are implemented well. Other libs have some problems -- http://webEbenezer.net/comparison.html<http://webebenezer.net/comparison.html> . I will say though that doing the right thing in my book usally means using Boost Intrusive and that Ebenezer Enterprises offers exclusive marshalling/serialization support for two Boost Intrusive containers. If there's interest in having marshalling support for other Intrusive containers, we are willing to consider adding more support in that area. Brian Wood Ebenezer Enterprises www.webEbenezer.net <http://www.webebenezer.net/> "Then Samuel took a rock and set it up between Mizpah and Shen. He named it Ebenezer [Rock of Help] and said, 'Until now the L-RD has helped us.'"

1 0

[multi_array] Negative strides
by John Reid 11 Jun '09

11 Jun '09

I could not find any support in boost::multi_array for negative strides. Does anyone know what the rationale was for not implementing them? John.

3 6

Proposal for #pragma once support
by Zachary Turner 11 Jun '09

11 Jun '09

I would like to propose conditional support for #pragma once be added to all header files in boost. This would involve, at the beginning of every header file, a preprocessor check to determine whether or not the particular compiler is on a whitelist of known compilers to optimized #pragma once. If so, #pragma once is used. so, something like this: #if defined(_MSC_VER) /* || defined(OTHER_PRAGMA_ONCE_ENABLED_COMPILER) ... */ #pragma once #endif the rest of the header file, including the original #include guard, could be as normal. to demonstrate the motivation for this, consider the sample on this page: http://www.gamearchitect.net/Articles/ExperimentsWithIncludes.html. At the bottom there is a zip file with a visual studio solution that contains 3 different projects. Each project contains 200 header file, each of which includes all of the other 199 header files. There is a single cpp file with a main function which includes all 200 header files. All 3 projects use internal #include guards. In addition: Project 'RedundantGuard' - Uses external include guards (wrapping the invocation of #include itself inside the appropriate guard) as discussed in the book Large Scale C++ Software Design Project 'PragmaOnce' - Uses #pragma once Project 'Nothing' - Uses nothing additional other than the internal include guards. Here are the build timings on my machine (Visual Studio 2008 Service Pack 2) RedundantGuard - 1 second compile + link time PragmaOnce - 1 second compile + link time Nothing - 15 seconds compile + link time In addition I have tested this in the code base of a commercial product I am working on (~40,000 lines of code). It consists of about 6 different projects, some of which have dependencies between each other and some which don't, so that parallel compilation can happen in some instances RedundantGuard - Not Tested PragmaOnce - 1 minute, 25 seconds compile + link time Nothing - 2 minutes, 1 second compile + link time So, I believe that boost compile times can benefit significantly from this. Thoughts?

20 38

Re: [boost] Proposal for #pragma once support
by Zachary Turner 11 Jun '09

11 Jun '09

On Tue, Jun 9, 2009 at 11:50 AM, <dherring(a)ll.mit.edu> wrote: > On Tue, 9 Jun 2009, Zachary Turner wrote: > > Here are the build timings on my machine (Visual Studio 2008 Service Pack >> 2) >> >> RedundantGuard - 1 second compile + link time >> PragmaOnce - 1 second compile + link time >> Nothing - 15 seconds compile + link time >> > ... > >> So, I believe that boost compile times can benefit significantly from >> this. >> >> Thoughts? >> > > Could you run benchmarks on gcc? Will my compile times suffer for your > improvement? > > - Daniel > It seems someone else in the thread has already run benchmarks on GCC, but regardless of how the benchmarks did or did not turn out, I can say with 100% certainty that nobody will suffer. That's the exact reason I mentioned that compilers should be whitelisted based on which ones benefit from #pragma once, and only use #pragma once for said compilers. #if defined(_MSC_VER) && (_MSC_VER >= 1020) #pragma once #endif That's all it takes. Everybody benefits. Of course I don't have licenses for every C++ compiler around, but I'm sure there are other compilres in which it benefits also. So I would need some assistance from other people who do have other compilers to help find out which compilers it does offer an improvement on. And of course, the default would be to NOT use pragma once, erring on the side of caution. If you see any downsides to this approach let me know, but it seems like a win/win for everyone. To make it even more explicit, there could even be a global macro, which defaults to undefined, called BOOST_USE_PRAGMA_ONCE. The programmer would be forced to explicitly declare this macro before including any boost headers, and if it is enabled, boost would use pragma once.

9 16

possible problem with boost::iostreams::file_descriptor
by Zachary Turner 11 Jun '09

11 Jun '09

nested file_descriptor implementation class is defined as follows: struct impl { impl() : #ifdef BOOST_IOSTREAMS_WINDOWS handle_(reinterpret_cast<handle_type>(-1)), #else handle_(-1), #endif flags_(0) { } impl(handle_type fd, bool close_on_exit) : handle_(fd), flags_(0) { if (close_on_exit) flags_ |= impl::close_on_exit; } ~impl() { if (flags_ & close_on_exit) close_impl(*this); } enum flags { close_on_exit = 1, append = 4 }; handle_type handle_; int flags_; }; In the second constructor in particular we have this: impl(handle_type fd, bool close_on_exit) : handle_(fd), flags_(0) { if (close_on_exit) flags_ |= impl::close_on_exit; } I think this should be changed. Just because close_on_exit is specified to false does not mean a file is not open. It just means don't close it if it is. I think flags enumeration should be changed to: enum flags { close_on_exit = 1, good = 2, append = 4 }; and constructors / code should be changed accordingly. Otherwise following code (Windows) asserts, even though I don't think it should: bool is_open(HANDLE h) { return h && h!=INVALID_HANDLE_VALUE;} HANDLE h = ::CreateFile("C:\\autoexec.bat", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); boost::iostreams::file_descriptor fd(h, false); BOOST_ASSERT(fd.is_open() == is_open(h)); Thoughts?

3 5