February 2009 - Boost - lists.preview.boost.org

[fusion] C++0x support?
by Ein Held 17 Mar '09

17 Mar '09

Hello is there any chance for c++0x support (rvalue forwarding for the containers' constructors and operator=s' in particular) for fusion in 1.39? If noone is up to adding support for this to fusion, my collegues and me would love to implement it. Thank you

5 10

Boost.Chrono where we are?
by vicente.botet 16 Mar '09

16 Mar '09

Hi, In November 2008, Beman said: "The Chrono library in the sandbox is now more-or-less feature complete." This library is esential to conform some boost libraries implementing standard libraries as Boost.Thread and Boost.Future as much as possible to the standard. It will be used also on the Boost.ThreasPool library and I would like also to use it on my AsynchronousExecutors library. Can we expect to have Boost.Chrono for review soon? Thanks, Vicente

1 1

request for discussion - yet another approach to automated memory management that solves the cycles problem and is very efficient
by Achilleas Margaritis 16 Mar '09

16 Mar '09

Dear boost members, The file 'mm2.zip' (in boost vault/memory) contains yet another solution for automatic memory management. The solution has the following attributes: 1) it solves the problem of cycles. 2) it releases resources deterministically. 3) it does not scan the graph of objects for reachability. It uses simple numeric values (i.e. keys) to determine if an object can be collected or not. The idea is very simple: pointers obtain keys during their construction (a simple global variable that is incremented). The key remains constant throughout the lifetime of a ptr. During pointer release, the pointers that point to an object are scanned: if there is no pointer that points to the object that has a lower key from the key of the releasing pointer, then the object can be deleted. The pointer semantics are normal C pointer semantics, except for the construction: the solution requires that pointers that are lvalues should obtain a key before the heap object that they will be assigned to. i.e. you can't do this: ptr p1 = new object; You have to do this: ptr p1; p1 = new object; All the operations have O(1) complexity, except the release operation, which has O(N) complexity, whereas N is the number of pointers that point to an object. Practically, the complexity is minimal, because it is rare to have that many different pointers to a single object (I think :-)). I have no idea if it works for all cases. The file 'main2.cpp' contains a lot of tests, which all pass. I have also included the benchmark of the Boehm GC modified to use my special ptr classes. In my machine, an Athlon 64 2.2 GHz, the benchmark is executed, using boost pools, at roughly 1900 milliseconds, whereas the Boehm gc benchmark, using the Boehm gc collector, is executed at roughly 1200 milliseconds (and the Java benchmark at roughly 600 milliseconds). The amazing thing is that it looks like it works, but I am not sure. I am sure there is a catch :-).

9 17

Re: [boost] [Boost-users] Maintenace Guidelines wiki page
by vicente.botet 15 Mar '09

15 Mar '09

----- Original Message ----- From: "Tomas Puverle" <Tomas.Puverle(a)morganstanley.com> To: <boost-users(a)lists.boost.org> Sent: Sunday, November 23, 2008 4:31 AM Subject: Re: [Boost-users] Maintenace Guidelines wiki page > >> I have started the Maintenace Guidelines wiki page. >> >> You can access it directly >> https://svn.boost.org/trac/boost/wiki/Guidelines/MaintenanceGuidelines >> >> or via https://svn.boost.org/trac/boost/wiki >> >> Guidelines >> * Maintenance Guidelines >> >> There page need to be completed and surely reworked but this is an starting >> point. >> >> Please be free to improve the page directly or post your comments or > suggestions to this list. >> >> Hopping this goes on the right direction, > > Vincente, > > A few ideas: How will you evaluate that your proposal is actually successful > and being followed by the boost developers? Hi, First this is proposal for guidelines. So people will be after all free to follow some of them or not. I'm expecting from people like you to improve it so it could be followed by more people. > Also, check out Daniel Walker's idea in the Boost.Range thread on boost.devel > about not having the engineers in charge of their own QA. Daniel Walker's idea " Perhaps a procedural solution that could avert this problem in the future is to quarantine the test cases. Authors can maintain commit privileges to their libraries on trunk, but only a select group of independent guardians have commit privileges to the test cases. That way there is a guarantee that libraries pass the same tests from one release to another. If an author would like to make a change that would break a test case, he or she would need to present the change to the list and submit a patch to the test case sentinels. This would be a fairly simple quality assurance protocol: engineers aren't allowed to do their own QA." This is already considered on the guidelines insome way. "Preserve the test from the preceding versions [author] The test from the preceding versions should not be changed when the author modifies its library. These not changed tests are a probe of compatibility with the preceding version. When these test must be changed they indicate a breaking user code issue. So instead of changing them add new ones stating explicitly on which version they were included. Old tests that should fail can be moved to the compile_fail or run_fail tests on the Jamfile. " The Daniel proposal implies some changes in the writing rights of the authors. I prefer to let this point out of these guidelines. Of course I think that this is a good idea. There is another guideline that could be used by the Boost comunity to check the author has not changed the old test cases. "Inspect announced modifications [author, user, RM] The use of the diff file will help to inspect that the modifications introduced have been correctly included on the documentation and a good test coverage has been done. This will result in a non official mini-review of the library. " I will add to check that the old testcases have not been changed. > Finally, please consider the idea of "core" and "new" release cycles, where the > components in "core" have much more stringent requirements on how and when they > are allowed to change. IMO this is out of the scope of the guidelines. Note that at the end it is up to the author to make the modification he/she consider pertinent. Could you send what you have in mind in the form of guidelines? > Finally, do you think it may have been better to start this thread on > boost.devel? I belived that i did it on both. I'm answering to both each time. Should I start a new thread including the guidelines contents? Vicente

14 46

[geometry] area, length, centroid, behavior
by Barend Gehrels 13 Mar '09

13 Mar '09

I would like to hear the opinion of potential geometry users on the list about the following. For the three geometries, point, linestring (= sequence of points), polygon: What should the generic "area" algorithm return for point and linestring? - 0 (zero) - compiler error (so this function is not defined for them at all) - exception Personally I would feel for 0 (zero) because you can then request the "area" in a generic collection, regardless of what is inside. What should the generic "length" algorithm return for polygon? - 0 (zero) - its perimeter - compiler error - exception What should the generic "centroid" algorithm return for point and linestring? - the point / the average its points - compiler error - exception and for an invalid polygon (e.g. no points at all, or not closed)? - exception - return "false" (if centroid is passed as a reference parameter) - ? (we've not always the compiler error option here because points are usually stored in a runtime collection) Thanks, Barend

15 66

Preview 4 of the Generic Geometry Library (ggl)
by Barend Gehrels 13 Mar '09

13 Mar '09

Dear list, It is a pleasure for us to present the fourth preview of the Generic Geometry Library. This time we've added the library to the SVN repository at boost, https://svn.boost.org/svn/boost/sandbox/ggl To store the library under a proper name, "ggl" is used, which stands for Generic Geometry Library. Before this we called it just Geometry Library, but we think Generic is appropriate from this version on. The first three previews were sent to this list in January, March and October 2008. Since then everything has been revised and reworked again, based on comments from the list. Thanks for all your comments! Concepts are now applied for all geometries. Algorithms now take any geometry fulfilling the concepts, and automatically take the right version of the underlying implementation. Ranges are now used instead of .begin()/end(). Tag dispatching is used instead of SFINAE. Transformations: previously these were just explained as an example, now transformations are included in the library, either to go from one coordinate system to another (for example from spherical to cartesian3D) or to translate/rotate/scale/map points from one Cartesian system to another, or otherwise. Map projections: included is an extensive addition with nearly 100 map projections. Those are not programmed by ourselves but automatically converted from C (PROJ4) into a our template-based approach, fitting with the geometry library, especially in the transformations explained above. License-wise this is possible. We're not sure about if this would fit in the Boost Library Collection, if there is interest in it, or that it might be "too much" for it, so we would be glad to hear your opinions. For more change descriptions, see the page on status and preview from the documentation (link below). The Generic Geometry Library is accessible from Boost SVN, mentioned above, or can be downloaded as well from http://geometrylibrary.geodan.nl Especially the examples, such as the custom point example and custom line string example show nicely how the library handles custom geometries and how they can be used inside the generic algorithms. We welcome any type of comment, opinion, cooperation, merge or join. Barend Gehrels, Amsterdam Bruno Lalande, Paris

3 11

[filesystem][cygwin] Standard conformance for wide characters
by Beman Dawes 11 Mar '09

11 Mar '09

I've decided not to attempt support for Cygwin in the next version of Boost.Filesystem. Cygwin's lack of library support for wchar_t is the problem . For the current Boost.Filesystem version (v2), the necessary workarounds are so pervasive that the implementation code is much harder to read and maintain. Witness the number of bug reports that are Cygwin specific. For v3, currently under development, trying to support Cygwin would be even harder, and would cause a serious delay in development. Plus I'm tired of waiting for the cygwin folks to come into full C++ conformance. IIUC, the reason Cygwin doesn't provide C++ standard library support for wchar_t is that the underlying C library is missing the C wchar_t functions. Perhaps Boosters who care about Cygwin could spearhead an effort to add the missing C support? The needed functionality isn't all that complex; the main problem might be just learning enough about how Cygwin/GCC is configured and built to be able to add a fairy small number of C functions. Thoughts? --Beman

10 29

Request for interest in the new Synchro library
by vicente.botet 10 Mar '09

10 Mar '09

Hi, I would like to know if the Boost community is interested in the Synchro library. Of course there is a lot of work to do, but I think that there is enough material to start a discussion on the approach. I'd appreciate it if people could take a look, test it on their compiler and give me some feedback. The library is available at Boost Sandbox: https://svn.boost.org/svn/boost/sandbox/synchro and Boost Vault: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=synchr… that iIncludes every thing on the Sandbox + Html documentation Some examples use Boost.Interthreads also (available on the vault and the sandbox). This library is a compilation of what I have found in the literature not yet present in Boost. My main concern has been to boostify all these ideas in a coherent way. Next follows an overview of the library features: Boost.Synchro provides: * A uniform usage of Boost.Thread and Boost.Interprocess synchronization mechanisms based on lockables(mutexes) concepts and locker(guards) concepts. o lockables traits and lock generators, o lock adapters of the Boost.Thread and Boost.Interprocess lockable models, o locker adapters of the Boost.Thread and Boost.Interprocess lockers models, o complete them with the corresponding models for single-threaded programs: null_mutex and null_condition classes, o locking families, o semaphore, o condition_lockable lock which put together a lock and its associated conditions. * A coherent exception based timed lock approach, * A rich palette of lockers as o strict_locker, nested_strict_locker, o condition_locker, o reverse_locker, nested_reverse_locker, o locking_ptr, on_dereference_locking_ptr, o externally_locked, * A polymorphic lockable hierarchy. * High-level abstractions for handling more complicated synchronization problems, including o monitor for guaranteeing exclusive access to an object, and o a so-called rendezvous mechanism for handling direct communication between objects concurrent_components via ports using an accept-synchronize protocol based on the design of the concurrency library in the Beta language. On going work * array_locker and tuple_locker locker containers. * A complement to the already present in Boost.Thread lock, try_lock free functions: o lock_until, lock_for, try_lock_until, try_lock_for Best regrads, Vicente Juan Botet Escribá

3 12

wiki.boost.org Ancient
by Joel 09 Mar '09

09 Mar '09

Can wiki.boost.org be redirected to someplace useful? Right now it is an advertisement for crystal clear software. It is a bad advertisement since it is from 2005. Even worse, it has a link to a "boost wiki" that isn't being updated and has spam hidden away in it. It claims not to be official, but if the url is wiki.boost.org, it IS official! Thanks! Joel

4 6

[optional] little addition
by Arno Schödl 07 Mar '09

07 Mar '09

I just started using boost::optional, and this proved to be generically useful, but I believe is currently not in boost::optional: template< class T, class Tcompatible > bool optional_assign( T& t, boost::optional<Tcompatible> const& optt ) { if( optt ) { t=*optt; return true; } else { return false; } } so you can write boost::optional< TMyValue > TryToGetT(); T t; if( !optional_assign( t, TryToGetT () ) { ... other way to get t ... } instead of the more verbose: boost::optional< TMyValue > TryToGetT(); T t; boost::optional< TMyValue > const& optt=TryToGetT(); if( optt ) { t=*optt; } else { ... other way to get t ... } get_optional_value_or is similar, but the alternative must be an expression and is eagerly evaluated, both of which may be undesirable. Arno -- Dr. Arno Schoedl · aschoedl(a)think-cell.com Technical Director think-cell Software GmbH · Invalidenstr. 34 · 10115 Berlin, Germany http://www.think-cell.com · phone +49-30-666473-10 · toll-free (US) +1-800-891-8091 Directors: Dr. Markus Hannebauer, Dr. Arno Schoedl · Amtsgericht Charlottenburg, HRB 85229

4 23

[1.38.0] PDF package of Boost documentation released.
by John Maddock 07 Mar '09

07 Mar '09

Folks, A package containing PDF versions of Boost's documentation is now available for Boost-1.38.0 from the usual sourceforge download site: http://sourceforge.net/project/showfiles.php?group_id=7586&package_id=15971… Please note that due to the diverse range of tools in use within Boost it has not been possible to produce PDF's for all of Boost's libraries, those currently included as PDF's are: accumulators any array asio bimap range complex-tr1 concepts config conversion date_time foreach function hash interprocess intrusive iterator math-gcd math mpi octonion optional phoenix program_options proto python_tutorial quaternion ref regex scope_exit signals static_assert string_algo thread tr1 tribool type_traits typeof units unordered variant xpressive Documentation for the following tools are also included in this package: bjam boost_build boostbook quickbook Regards, John Maddock.

6 9

Formal Review: Boost.RangeEx
by Thorsten Ottosen 06 Mar '09

06 Mar '09

Dear Developers and Users, It's my pleasure to announce that the review of Neil Groves' RangeEx library starts today and lasts until March 3, 2009. What is it? +++++++++++ The library provide two very useful extensions to the range library 1. Range-based algorithms. E.g. boost::sort( rng ); which is a convenient wrapper of instead of std::sort( boost::begin(rng), boost::end(rng) ); But the new interface also allows for more expressive code because (on the fly) composition of algorithms suddenly is possible. 2. Range adaptors. E.g. std::vector<int> vec = ...; boost::copy( vec | boost::adaptors::reversed, std::ostream_iterator<int>( std::cout ) ); where the expression "vec | boost::adaptors::reversed" wraps the iterators of the range on the left in reverse iterators. The library provides a wide range (no pun intended) of Range adaptors, and they are a powerful way to create ranges on the fly and pass them to algorithms. Getting the library +++++++++++++++++++ The library may be downloaded from http://www.cs.aau.dk/~nesotto/boost/range_ex.zip or from the Boost vault under "Algorithms". The docs may be browsed online here http://www.cs.aau.dk/~nesotto/boost/libs/range/ Please note that the documentation is integrated with the current Range ilbrary. Therefore the relevant sections for the review is http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/adaptors.html and http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/algorithms.html The code may be browsed here: http://www.cs.aau.dk/~nesotto/boost/boost/range/ Notice the library is header only (exception: the adaptor tokenized() depends on Boost.Regex). 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. Special considerations ++++++++++++++++++++++ Various RangeEx like libraries have been implemented in the past. You might want to compare with those libraries when you form your oppinion: 1. John Torjo's range lib http://rangelib.synesis.com.au/libs/boost-rangelib-20040913.zip http://torjo.com/rangelib/index.html 2. Adobe's ASL libraries include range-based algorithms: http://stlab.adobe.com/group__algorithm.html I'm looking forward to your review. best regards Thorsten, Review Manager

18 101

BGL question about districting
by Barend Gehrels 06 Mar '09

06 Mar '09

Hi, We're about an automated districting tool. We want to create Y districts from X polygons, all having a specific value (e.g. area or inhabitants), where the total value of each district is as similar as possible and each district is also as similar as possible. Let's call the value the "potential". Of course this problem is NP-hard so we're glad with the first solution or e.g. the first ten solutions. We thought to implement this by the Boost Graph Library. First we detect neighbour relations with our own Geometry Library (using the still-to-build "touches" relationship). We've a graph then and can divide the graph into subgraphs, each having connected nodes and an (nearly) equal "potential". I've some experience with BGL, having used the "connected_components". But I cannot find an appropriate algorithm for this problem, if it is available. Actually it even could be a "network flow" algorithm dividing the total potential by Y, and starting at some point flowing the potential through the graph. But all network flow algorithms seem to be on directed graphs. This is an undirected graph. It it is not possible with a standard BGL algorithm I think we can still solve it using BGL and e.g. breadth-sort-first, but just want to verify if it is possible or maybe by an unexpected workaround. Thanks, Barend

4 5

[time series] What happened to this library?
by Christian Henning 05 Mar '09

05 Mar '09

Hi there, as far as I can tell this lib has been approved but it doesn't show up in boost. Why is it not in there? Thanks, Christian

11 21

Design conventions; passing functors
by Joachim Faulhaber 04 Mar '09

04 Mar '09

Hi, I am pondering about functor passing. Functors occur in my library (ITL) e.g. for the aggregation of associated values on insertion in interval_maps (aggregation on overlap): template<class Domain, class Codomain, ...> class interval_map{ ... //(1) My current implementation is this: // Combinator is the aggregating functor template, // instantiated at compiletime template<template<class>class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator template passed or instantiated somewhere*/ } ... } //I like this definition, because it's abstract: // The functor has to be a matching template e.g. inplace_max interval_map<int,int> m; m.add<inplace_max>(some); //(1) template<class Domain, class Codomain, ...> class interval_map{ //(2) The more traditional definition template<class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator type passed or called somewhere*/ } ... m.add<inplace_max<int> >(some); //(2) I prefer (1) but both definitions (1) and (2) are purely static denotations. To have adaptable functors or functors that can have states, like in ... m.add(some, max_under(42)); ... I am afraid I have to say sayonara to definition (1) and use this instead: template<class Domain, class Codomain, ...> class interval_map{ //(3) Adaptable functor template<template<class>class Combinator> interval_map& add(const value_type& value_pair, const Combinator<Codomain>& combine) { /*combine functor passed or called somewhere*/ } Now, there seems to be a convention from the STL that functors shall be passed BY VALUE. template<template<class>class Combinator> interval_map& add(const value_type& value_pair, Combinator<Codomain> combine); This is stated in [Sutter & Alexandrecu 2005, C++ Coding Standards] item 89: "Function objects are modeled on function pointers. Like function pointers, the convention is to pass them by value. All of the standard algorithms pass objects by value, and your algorithms should too." I do not really understand this convention and feel some resistance to follow it. In addition the call by value implementation can (and will) lead to heavy inefficiency by unaware usage of fat functors. So I browsed through some boost libraries and found that functors are passed by reference there (e.g. accumulators, fusion). Final question: What is the boost standard on passing functors, that I can adapt to? Cheers Joachim

6 20

Re: [boost] [optional_io] InputStreamable refinement
by Andrew Troschinetz 04 Mar '09

04 Mar '09

Just heard back from Robert, I figure it's ok to forward this information: On Feb 26, 2009, at 10:00 AM, Robert Ramey wrote: > The serialization library does no depend up optional or it's > implementation. If you > change the implemenation of optional, just make the changes > are consistent with the requirements of the serialization library. > > The fact that the serialization of optional is implemented and tested > as part of the serialization library is an anomoly. In fact, this > code and test should be moved into the optional library. I checked the optional test in the serializable library and it doesn't seem to even include optional_io.hpp. And given Robert's comments, it seems like it would be ok to make changes to optional_io.hpp. With respect to the change I suggested for operator>>() (I think in my last post I typoed and wrote operator<<(), I always get those silly things backwards!): In the case where we fail to extract optional<T>::value_type, I'm not sure what would be the best thing to do with respect to the position of the get pointer or other state bits. I had suggested this: if (in.fail () && !in.eof ()) { in.clear (); in.get (); } The intent of calling get() there is to enable this use case: stringstream sin ("one 2 three 4 five 6"); optional<int> i; while (sin >> i) { if (i) cout << "found int: " << i << endl; } // which finds 2, 4, and 6 But why move the get pointer up by one? Why one? Does this make sense? I can't provide a reasoning as to why it does, if it does. So another possibility is this: if (in.fail () && !in.eof ()) { in.clear (); in.setstate (std::ios::eofbit); } This has the added benefit of of making the following possible w/o any code change to lexical_cast: // doesn't throw, returns 0 lexical_cast<optional<unsigned> > ("-1").get_value_or (0); And if it's well documented that extracting an uninitialized optional<T> sets the eofbit on the istream, then a prudent user could (if they really wanted to) reformulate the first use case as: stringstream sin ("one 2 three 4 five 6"); optional<int> i; while (sin >> i) { if (i) cout << "found int: " << i << endl; else { sin.clear (); sin.get (); } } This leaves the why of moving the get pointer up to the user, where I think it really belongs. Because I can image some use cases where you'd want to do something other than just call get(). For example, maybe you'd want to call getline() and ignore an entire line before trying to extract another optional<T>. Or maybe you'd want to read until you found some delimiter before trying again. -- Andrew Troschinetz Applied Research Laboratories

4 9

Re: [boost] An extension to boost::variant
by Catalytic 04 Mar '09

04 Mar '09

Chris Hamilton-3 wrote: > > While boost::variant is very capable at what it does, there is one thing > it doesn't do .. > > ..My question is this: why can't boost::variant be clever about reference > data types.. > > The reason I want this, is to have a nice String variant, that > encapsulates the various forms a string can take in a current project: > std::strings, char*'s, and std::string* and > boost::shared_ptr<std::string>. I want functions to be able to handle > all of these types transparently by using variants as the argument > types. Allowing "const std::string&" as a variant type allows this to > be done while not requiring a wasteful string copy. > .. > (I have a small custom variant class implementing this, and it appears > to work well. It's not as 'full fledged' as the boost::variant class, > but the approach I've taken could surely be grafted on to boost::variant.) > > An example will be better than a lengthy explanation, please have a look at the test-cases in the boost distribution: libs/variant/test/: specially variant_reference_test.cpp IMHO, it will answer all your queries. -Cat -- View this message in context: http://www.nabble.com/An-extension-to-boost%3A%3Avariant-tp21881442p2189668… Sent from the Boost - Dev mailing list archive at Nabble.com.

5 13

[convert] Default Syntax Idea
by Stewart, Robert 04 Mar '09

04 Mar '09

I was thinking a bit about syntax for the default value for the notional boost::convert() and kin. How about the following: int const i(3); string const s("something"); int const j(convert<int>(s) | 5); convert<DestType,SourceType>(SourceType) can return a type which throws on failure in operator DestType(), but has an operator |(SourceType) which returns a second type constructed with the SourceType value. The second type provides its own operator |(SourceType) which returns that value in its operator DestType() on failure. Returning a default value in lieu of an exception is a special case; it ought not be treated like formatting. Thus, while Boost.Parameter might be appropriate to package the extra information desired for formatting, I don't like the idea of writing "default_ = 5" in the call, and I don't think ", 5" in the argument list is as clear as it could be. The syntax above is obvious and concise while being distinct from whatever may be done for formatting. _____ Rob Stewart robert.stewart(a)sig.com Software Engineer, Core Software using std::disclaimer; Susquehanna International Group, LLP http://www.sig.com IMPORTANT: The information contained in this email and/or its attachments is confidential. If you are not the intended recipient, please notify the sender immediately by reply and immediately delete this message and all its attachments. Any review, use, reproduction, disclosure or dissemination of this message or any attachment by an unintended recipient is strictly prohibited. Neither this message nor any attachment is intended as or should be construed as an offer, solicitation or recommendation to buy or sell any security or other financial instrument. Neither the sender, his or her employer nor any of their respective affiliates makes any warranties as to the completeness or accuracy of any of the information contained herein or that this message or any of its attachments is free of viruses.

9 32

boost::bind, problem with result type deduction and calling conventions
by Ingo.Loehken＠boc-eu.com 03 Mar '09

03 Mar '09

hi, anybody able to explain, why the code for the result type, related to special calling conventions defines an void return type ? template< class R, class T > struct add_cref< R (T::*) (), 1 > { typedef void type; }; so that code like class A { public: int __stdcall x() { return 0; } void const y() {} explicit A() { typedef boost::function<int()> fun_t; fun_t const f(boost::bind(&A::x,this)); } }; ends up with an warning at bind 1>G:\boost\boost_1_37_0\boost/bind.hpp(1643) : warning C4180: qualifier applied to function type has no meaning; ignored 1> G:\boost\boost_1_37_0\boost/bind.hpp(1682) : see reference to class template instantiation 'boost::_bi::add_cref<Pm,I>' being compiled 1> with 1> [ 1> Pm=int (__stdcall Ado::A::* )(void), 1> I=1 1> ] 1> G:\dev\workspace\files\ado\ado_bind.hxx(36) : see reference to class template instantiation 'boost::_bi::dm_result<Pm,A1>' being compiled 1> with 1> [ 1> Pm=int (__stdcall Ado::A::* )(void), 1> A1=Ado::A * 1> ] because the proposed specialization is not choosen by the compiler. Adding an __stdcall to the function signature type in add_cref fixes that problem, but still i do no understand, why the defintion is not like template< class M, class T > struct add_cref< M (__stdcall T::*) (), 1 > { typedef M const& type; }; and of course that fix is only applicable for __stdcall, where specialzations for other calling conventions can easily be generated, like for mem_fn_cc in respect to requested support for calling conventions. Thanks for your help, ILo. compiler : msvc 8.0 library : boost 1.38

2 1

[Review] Reminder: Boost.RangeEx review is going on
by Thorsten Ottosen 02 Mar '09

02 Mar '09

Dear Developers and Users, The review of Neil Groves' RangeEx library lasts until March 3, 2009. Please find the time to do a review if you are interested in this library. The discussion so far may be found here: http://archives.free.net.ph/message/20090220.122836.73bdbd04.en.html Below you will find a description of the library and information on how to write a review. best regards Thorsten, review manager What is it? +++++++++++ The library provide two very useful extensions to the range library 1. Range-based algorithms. E.g. boost::sort( rng ); which is a convenient wrapper of instead of std::sort( boost::begin(rng), boost::end(rng) ); But the new interface also allows for more expressive code because (on the fly) composition of algorithms suddenly is possible. 2. Range adaptors. E.g. std::vector<int> vec = ...; boost::copy( vec | boost::adaptors::reversed, std::ostream_iterator<int>( std::cout ) ); where the expression "vec | boost::adaptors::reversed" wraps the iterators of the range on the left in reverse iterators. The library provides a wide range (no pun intended) of Range adaptors, and they are a powerful way to create ranges on the fly and pass them to algorithms. Getting the library +++++++++++++++++++ The library may be downloaded from http://www.cs.aau.dk/~nesotto/boost/range_ex.zip or from the Boost vault under "Algorithms". The docs may be browsed online here http://www.cs.aau.dk/~nesotto/boost/libs/range/ Please note that the documentation is integrated with the current Range ilbrary. Therefore the relevant sections for the review is http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/adaptors.html and http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/algorithms.html The code may be browsed here: http://www.cs.aau.dk/~nesotto/boost/boost/range/ Notice the library is header only (exception: the adaptor tokenized() depends on Boost.Regex). 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. Special considerations ++++++++++++++++++++++ Various RangeEx like libraries have been implemented in the past. You might want to compare with those libraries when you form your oppinion: 1. John Torjo's range lib http://rangelib.synesis.com.au/libs/boost-rangelib-20040913.zip http://torjo.com/rangelib/index.html 2. Adobe's ASL libraries include range-based algorithms: http://stlab.adobe.com/group__algorithm.html I'm looking forward to your review. best regards Thorsten, Review Manager

4 5

N2346 - Defaulted and Deleted Functions emulation
by vicente.botet 02 Mar '09

02 Mar '09

Hi, is there an interest in a N2346 - Defaulted and Deleted Functions emulation http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm The idea been to use some macros that will use the =default, =delete if the compiler provides it and replace this macros by whatever has the same semantics. Alexandrescu introduced already two macros NON_ALIAS and NON_HEAP_ALLOCATED when talking about strict locks. Attached a draft for the default and deleted functions. Only one remark the macors must be used on the public part and without trailing ';', e.g. class X { BOOST_NEW_DELETE(X) Any coments are welcome, Vicente

3 6

[geometry] gtl review pre-announcement
by Tom Brinkman 02 Mar '09

02 Mar '09

I'm doing a session at boostcon about GIL and making a bunch of examples, including some about GTL. You can include those as part of your unit test cases if you like. //Tom

3 2

RPC library in the sandbox
by Jon Shuler 02 Mar '09

02 Mar '09

Does any know if the author(s) of this library are still around and plan to make any more updates to it? Jon

2 1

[thread] static thread_specific_ptr?
by k-oli＠gmx.de 01 Mar '09

01 Mar '09

Hello, can I create an static thread specific pointer for class which will initalized by different threads? struct X { static thread_specific_ptr< U > tss_ptr_; }; in some threads: X::tss_ptr_.reset( new U); And for each thread X::tss_ptr_ will point to a different object in the freestore? Oliver

6 8

rule cpp-pch unknown in module Jamfile</D:/boost/trunk/libs/math/build>?
by Peter Dimov 01 Mar '09

01 Mar '09

I'm trying and failing to run the smart_ptr tests because of: D:\boost\trunk\libs\smart_ptr\test>bjam ..\..\..\libs\math\build\Jamfile.v2:8: in modules.load rule cpp-pch unknown in module Jamfile</D:/boost/trunk/libs/math/build>. D:/boost/trunk/tools/build/v2/build\project.jam:313: in load-jamfile D:/boost/trunk/tools/build/v2/build\project.jam:62: in project.load D:/boost/trunk/tools/build/v2/build\project.jam:742: in project.use D:/boost/trunk/tools/build/v2/build\project.jam:89: in load-used-projects D:/boost/trunk/tools/build/v2/build\project.jam:73: in load D:/boost/trunk/tools/build/v2/build\project.jam:115: in load-parent D:/boost/trunk/tools/build/v2/build\project.jam:448: in initialize D:/boost/trunk/tools/build/v2/build\project.jam:303: in load-jamfile D:/boost/trunk/tools/build/v2/build\project.jam:62: in load D:/boost/trunk/tools/build/v2/build\project.jam:168: in project.find D:/boost/trunk/tools/build/v2\build-system.jam:535: in load D:\boost\trunk\tools\build\v2/kernel\modules.jam:283: in import D:\boost\trunk\tools\build\v2/kernel/bootstrap.jam:138: in boost-build D:\boost\trunk\boost-build.jam:17: in module scope -- Peter Dimov http://www.pdplayer.com

4 7