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

Submission of a new application to 'Who's Using Boost'
by Carlo Medas 05 Mar '09

05 Mar '09

Dears, this is a submission of a brand new free application which is using boost. It is also a chance to say thanks to you all. Boost is amazing and thanks to your excellent work we've been able not only to speed up the development but also to make the new app available on several platforms, without a huge effort. Application name: fing Company/team name: overlook App description: Fing is the ultimate command line tool for network and service discovery; born from the ashes of Look@LAN, it takes advantage of a brand new cross-platform network engine and reaches an impressive discovery sharpness and speed. Its network discovery reaches 100% hit in any ethernet-based network. Supported operating systems: Linux, Mac OS, Windows. Boost parts used: thread, system, filesystem, asio, multi-index containers, smart pointers, program options URL: http://www.over-look.com Thank you all once more for your great work, Overlook team Carlo Medas, Daniele Galdi, Marco De Angelis

2 1

Re: [boost] [math] Does any one interesting in calculating derivative for a expression automatically?
by Dongfei Yin 05 Mar '09

05 Mar '09

Hi Bruno, thank you for your interesting, I will try to use proto, I never use it before. yes, It's technically feasible. but the type of all the symbol in the expression can not be the build-in type. and gamma function should be a special version. integral is more difficult than derivative, else, to calculate the volume will be more easier. to simplify the expression is a interesting work. especially in compile time. BTW: I do not know how to upload source to this system, do you know how to do that? Dongfei. > >From my point of view, the main interest would be to compute > expressions containing some compile-time values provided by the user. > For example I want to calculate the volume of a hypersphere which is: > (pi^(N/2)*r^N) / gamma(N/2 + 1), with dimension N known at > compile-time. If the user happens to work only with N=2, that is > circles, I want the resulting expression to be as effective as a > hand-written pi*r^2 (the volume of a hypersphere<2> is the area of a > circle). It's technically feasible. > > Bruno > >

3 2

BoostCon '09 Sessions
by David Abrahams 05 Mar '09

05 Mar '09

Hartmut Kaiser and the BoostCon Program committee have done a stellar job assembling a list of sessions for this year's BoostCon, including everything from C++ compiler developer presentations, to hands-on C++0x development, to talks on eexperimental metaprogramming enhancements, to expression templates for running code on GPUs. I can honestly say I want to go to almost every session. It's going to be hard to choose. Please see the session list at: http://www.boostcon.com/program/sessions and then, of course, head on over to http://www.boostcon.com/registration to register for the conference. Best regards to all. See you there! -- Dave Abrahams BoostPro Computing http://www.boostpro.com

1 0

[serialization] string serialization
by Nikolay Mladenov 04 Mar '09

04 Mar '09

Hi, I the basic_binary_iprimitive.ipp (and I suppose other files) the size of the strings is serialized as std::size_t and not as serialization::collection_size_type. Is that intentional? Thanks, Nikolay Mladenov

4 11

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

[serialization] problems implementing free-standing functions
by Thorsten Ottosen 04 Mar '09

04 Mar '09

Hi, I'm having some annoying problems when implementing serialization for the attached class. Basically I define boost::serialization::load()/save(). I do just like done in e.g. boost.ptr_container, so I'm really confused about what's going on here. From the error message it looks like the free-standing functions are not found. Any help will be greatly appreciated. Thanks -Thorsten

3 12

[serialization] automation of class version sanity checking
by troy d. straszheim 04 Mar '09

04 Mar '09

Hey (Robert), Use case. It is possible (and does happen) that a user tries to deserialize version N+1 of a class C with software that only understands versions up to N. What typically happens is that C appears to deserialize OK, but it has eaten too many (or few) bytes from the archive. This means that the next class that gets loaded from the archive will fail in some unpredictable way. To deal with this we've started adding the following to all of our classes: struct C { double x; // this was present in version 0 double y; // this arrived with version 1 template <typename Archive> void serialize(Archive& ar, const unsigned int version); }; BOOST_CLASS_VERSION(C, 1); template <typename Archive> void C::serialize(Archive& ar, const unsigned int version) { if (version > 1) throw unsupported_version(version, 1); if (version == 0) ar & x; if (version == 1) ar & y; } ( Note the two arguments to unsupported_version ). This has the pleasant side effect of often catching errors in *other* classes. Eg if I'm trying to deserialize C and that exception is thrown, you can generate a message "trying to read version 3243856293 of class C, but I only know about version 0-1". Now I know that something has gone quite wrong, for instance someone has removed a member from my enclosing class without correctly incrementing and handling the version there, and what I've been given as 'version' is garbage. If the message is instead "trying to read version 4 of class C but I only know about versions 0-3", it looks like I simply need to update my software, nothing more sinister. This greatly simplifies these situations, which otherwise could spiral into a long, painful back-and-forth over a segfault in a serialization routine involving questions about what software the user has, where the data came from, what software was used to write it, etc. So: 1. I can't think of a situation where having file_version greater than BOOST_CLASS_VERSION isn't a catastrophic error. 1a. It'd be nice to configurably auto-check for this kind of versioning error. 2. As far as I can tell, these checks could be done cleanly inside the library, in serialize_adl() (?). 3. We don't actually use that unsupported_version exception, which takes no arguments and is thrown from serialization of variant (I wrote that and now find it confusing). I think the variant error should be specific to variant (or just totally generic), and unsupported_version should be used for the case currently under consideration... and to enable the 'pleasant side effect' above, I think the exception should carry the greatest version known to the code and the attempted-to-read version. Sanity check please, say so if you want me to try implementing... -t

2 2

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

boost versioned namespace ?
by Roland Schwarz 04 Mar '09

04 Mar '09

I am seeking advice on how I could package some of boosts libraries as part of a library I am writing. Given: "libboost_1_35" a boost lib at ver. 1_35 which is used by my "libmy". I need to be able to ship binary versions of "libmy" and "libboost_1_35". A customer writing an application "app" and using "libmy" and "libboost_1_39". The problem: libboost_1_39 and libboost_1_35 likely will have common symbols, which either prevents the customer to use 1_39 or forces me to also upgrade to 1_39 (altough everything is fine with 1_35). The questions: What would boosters recommend? Is there a way to use kind of a versioned boost namespace? Regards, speedsnail

3 4

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