- Boost-users - lists.preview.boost.org

cvs serialization error
by Chris Coleman 19 Jul '05

19 Jul '05

Hi, While using the boost cvs sources on Mac OS X 10.4.2 I have come across the error below: (I'm using the cvs since 1.32 wont build on 10.4 due to apple? removing one of the gcc compiler flags...) In file included from /usr/local/include/boost/archive/detail/basic_oarchive.hpp:25, from /usr/local/include/boost/archive/detail/oserializer.hpp:58, from /usr/local/include/boost/archive/basic_text_oarchive.hpp:32, from /usr/local/include/boost/archive/text_oarchive.hpp:31, from ./zz_cell_zri.h:28, from ./zz_public_cell.h:27, from ./zz_cell_set.h:21, from ./mantra_response.h:32, from ./mantra_request_abstract.h:26, from mantra_request_admin.h:21, from mantra_request_admin.cpp:16: /usr/local/include/boost/archive/basic_archive.hpp:21:2: error: #error "no serialization headers my precede any archive headers" Cheers Chris This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

2 2

Phoenix lazy functions
by Edson Tadeu 19 Jul '05

19 Jul '05

I'm trying to learn to use Phoenix, but I haven't found an example of how to do the following simple thing using its inline lazy function creation (it seems that there isn't a simple way to do this): struct Test { int x; void Test() {x = 1;} void inc(int i) { x += i; } }; void main() { vector<Test> v; v.resize(5); // v == {1, 1, 1, 1, 1} for_each(v.begin(), v.end(), arg1.inc(1 + arg1.x) ) // v == {3, 3, 3, 3, 3} } The only ways I found to do this involves function<> that needs an external functor declaration, but this is ugly just like old STL functors, or using member_function_ptr and member_var_ptr templates, but I couldn't get them to work on Borland C++. Anyone knows how to do it, keeping simplicity and elegance? Thanks in advance!

2 1

ICE in multi_index - solved
by Jasper, Alexander 18 Jul '05

18 Jul '05

Hi All! I've solved the ICE in VC 7.1 and multi_index: don't use /Gm (ie. "Minimal rebuild") Than it works ok. But I'm still unable to build the release verison of date_time, though. kind regards Alex

1 0

Boost warning policy
by Yuval Ronen 18 Jul '05

18 Jul '05

Hi. Is there some "official" Boost warning policy? What I mean is something like: "If you use Boost with VC7.1, then you should work with warning level X, warnings A, B and C enabled, and warning D, E and F disabled. If you work this way, you won't get any warnings from Boost code. If you still do, then it's our bug. Please report it so we can fix it." Is there something like that? I searched the docs, but found nothing of this sort. Thanks, Yuval

2 1

Question about the comment in boost::thread condition.hpp
by Georgi Yaralov 18 Jul '05

18 Jul '05

Can anybody shed a light on this? // 23 May 01 WEKEMPF Removed "duration" timed_waits, as they are too // difficult to use with spurious wakeups? I need relative time waits and this comment made me wary. Thanks for your time, Georgi

2 1

date_time exception safety
by Serge Skorokhodov 18 Jul '05

18 Jul '05

Hi, Do I understand right that ptime assignment is trough automatically generated operator and that it is exception safe? TIA -- Serge

1 0

Lookbehind assertions problem with 1.33
by Gregory Nisnevich 18 Jul '05

18 Jul '05

I'm trying to use lookbehind assertions, and here's a problem: the following syntax (?<=^.{2}).{4} gives me the error: '(?<=^.{2}).{4}' is a bad regular expression: Unmatched [ or [^ while the following works: (?<=^..).{4} matching, as I expected, 4 characters after the first 2 characters in a line. Shouldn't the above two regexes work the same way? Thanks, -Gregory __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

2 4

Specifying an alternate 'operator>>' for istream_iterator
by remi.chateauneu＠gmx.de 18 Jul '05

18 Jul '05

For istream_iterator or ostream_iterator, the operator '<<' and '>>' are used to serialize the data. Have anyone ever needed another operator (typically for serializing to another format, for example binary) ? To implement this, it seems possible to add the serializing operator to istream_iterator, as an extra template argument, which would by default use the existing operator>>. In other words : template<typename _Tp, typename _CharT = char, typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t> class istream_iterator { ... ... would be replaced by something like : template<typename _Tp, typename _CharT = char, typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t, typename _SerializingOperator = XXXXX > class istream_iterator { ... XXXXX would represent the existing operator>> for this data type. On the other hand, 'operator>>' is not a method of class _Tp, but a friend method. So, how to specify it are a default template argument ?

2 1

documentation lacuna in boost::unit_test v1.33?
by Serge Skorokhodov 18 Jul '05

18 Jul '05

Hi, I run into a problem switching from unit_test 1.32 to 1.33. The code for test log configuration must be changed from something like using namespace boost::unit_test; unit_test_log::instance().set_log_threshold_level(...) etc. to something like unit_test_log.instance().set_threshold_level(...) etc; I believe that it worth mentioning in release notes;) Another question: it is still impossible to link main implementation automatically in the lib rather than pull it in directly with #include "boost/test/included/unit_test_framework.hpp"? -- Serge

1 0

Re: [Boost-users] tuple
by Bjorn.Karlsson＠readsoft.com 17 Jul '05

17 Jul '05

Hello Jim, > "Jim Pritts" <jpritts(a)sdf.lonestar.org> wrote in message > > Is it possible to do something like the following: > > typedef boost::tuple<double, int, int> element; > > std::vector<element> d; > > std::vector<element>::iterator i = std::max_element(d.begin(), > d.end(), > > bind(std::max<double>,bind(get<0>,_2),_1)); Good question! The above won't compile, in part because get() requires three template arguments, so you can't get it's address using &get<0>. Furthermore, it's not trivial to explicitly instantiate get() correctly or to bind to tuple's member function get(), which is why I'd suggest creating a helper class--a function object--for selecting one of the elements of a tuple. To use it with Boost.Bind without explicitly specifying the return type, you'd need to do this: template <typename T,int i> class select { public: typedef typename boost::tuples::element<i,T>::type result_type; template <typename U> result_type operator()(const U& u) const { // Select the ith element of the tuple T and return it return u.get(); } }; The required typedef, result_type, that enables Boost.Bind to deduce the return type of the function call operator, uses a helper class from Boost.Tuples, the class template element, which retrieves the type of a tuple element using its index. With a class template like select, you could use Boost.Bind with max_element like so: int main() { typedef boost::tuple<double,int,int> element; std::vector<element> d; // Code for adding elements omitted std::vector<element>::iterator i= std::max_element( d.begin(), d.end(), boost::bind(std::less<double>(), boost::bind(select<element,0>(),_1), boost::bind(select<element,0>(),_2))); } You'll also note that I've adjusted the binders from the example you gave. There are three binders in the call to max_element; the two innermost binders extract the first element of the tuples _1 and _2 (to be substituted with the actual arguments), and the third binder binds std::less<double>. The result of all these binders is a binary predicate, which is what std::max_element expects. Note that in your example, you had used std::max(), which does not work well as a binary predicate for max_element(). Although the above version of select works, it's rather inflexible and sometimes inefficient, because the function call operator always returns a copy of the ith element of the tuple. What if you need to assign a value to that element? To enable that, you'll need a new version of select, a class template that is only parameterized on the element index, and with two parameterized function call operators that return a copy of the element or a reference to the element, depending on the constness of the tuple. Using Boost.Type_traits, it's easy to add a reference to a type without risking forming a reference to reference (those are currently illegal in C++): template <int i> class select { public: template <typename T> typename boost::tuples::element<i,T>::type operator()(const T& t) const { // Select the ith element of the tuple t and return it return t.get(); } template <typename T> typename boost::add_reference<typename boost::tuples::element<i,T>::type>::type operator()(T& t) const { // Select the ith element of the tuple t and return it return t.get(); } }; This version of select works fine, but Boost.Bind is no longer able to deduce the return type of the function call operator(s), so you'll need to provide that information explicitly when using select: std::vector<element>::iterator i= std::max_element( d.begin(), d.end(), boost::bind(std::less<double>(), boost::bind<double>(select<0>(),_1), boost::bind<double>(select<0>(),_2))); If you think we're all done here, think again. ;-) When using Boost.Lambda, which also offers binders, there's an extended system for deducing return types. It comes in the form of a nested class template called sig that is responsible for providing the correct return type depending on which function call operator is being called, i.e., depending on the actual arguments to the function call operator(s). That is precisely the kind of mechanism that you need to solve the problem with the multiple function call operators of select. The following version of select is the most user-friendly version, but it is a little more complex. It uses Boost.Mpl for a compile-time if, Boost.Type_traits for adding a reference to the element type, Boost.Lambda's return type deduction system, and of course Boost.Tuples to operate on the tuple and retrieve the ith element's type: template <int i> class select { public: // Provide the return type template <typename Arg> class sig { typedef typename boost::tuples::element<1,Arg>::type argument_type; typedef typename boost::tuples::element<i,argument_type>::type element_type; public: // Select the correct return type; depends on the typedef typename boost::mpl::if_<boost::is_const<element_type>, element_type, typename boost::add_reference<element_type>::type>::type type; }; template <typename T> typename boost::tuples::element<i,T>::type operator()(const T& t) const { // Select the ith element of the tuple t and return it return t.get(); } template <typename T> typename boost::add_reference<typename boost::tuples::element<i,T>::type>::type operator()(T& t) const { // Select the ith element of the tuple t and return a reference to it return t.get(); } }; Using this version of select and Boost.Lambda's binders, you'll have both an easy-to-use interface and a powerful way of selecting tuple elements, both for lvalues and rvalues. Here's a complete program to demonstrate your example again. Note that the class template select requires you to include the headers "boost/tuple/tuple.hpp", "boost/type_traits.hpp", and "boost/mpl/if.hpp". For Boost.Lambda's bind(), you'll need to include "boost/lambda/bind.hpp". #include <iostream> #include <vector> #include <algorithm> #include <functional> #include "boost/tuple/tuple.hpp" #include "boost/type_traits.hpp" #include "boost/mpl/if.hpp" //#include "boost/lambda/bind.hpp" template <int i> class select { public: // Provide the return type template <typename Arg> class sig { typedef typename boost::tuples::element<1,Arg>::type argument_type; typedef typename boost::tuples::element<i,argument_type>::type element_type; public: // Select the correct return type; depends on the typedef typename boost::mpl::if_<boost::is_const<element_type>, element_type, typename boost::add_reference<element_type>::type>::type type; }; template <typename T> typename boost::tuples::element<i,T>::type operator()(const T& t) const { // Select the ith element of the tuple t and return it return t.get(); } template <typename T> typename boost::add_reference<typename boost::tuples::element<i,T>::type>::type operator()(T& t) const { // Select the ith element of the tuple t and return a reference to it return t.get(); } }; int main() { typedef boost::tuple<double,int,int> element; std::vector<element> d; // Code for adding elements omitted using namespace boost::lambda; std::vector<element>::iterator i= std::max_element( d.begin(), d.end(), bind(std::less<double>(), bind(select<0>(),_1), bind(select<0>(),_2))); std::cout << "max element: " << (*i).get<0>(); } Regards, Bjorn Karlsson

1 0