- Boost - lists.boost.org

boost::lambda::operator* and smart pointers
by Maxim Yegorushkin 23 Mar '04

23 Mar '04

Hi guys. I encountered a pitfall when trying to use boost::lambda for dereferencing a smart pointer. Current lambda implementation assumes that operator*() can be applied to either a plain pointer or an iterator. That leads to an error message when applying the operator to a smart pointer complaining about std::iterator_traits<> not being specialized for the smart pointer. Consider the code: struct some { void foo(int); }; boost::shared_ptr<some> ptr(new some); ( lm::bind( &some::foo , *lm::_1 , 0 ) ) (ptr); the bind expression won’t compile until we hack std::iterator_traits<boost::shared_ptr<> >: template<class T> struct std::iterator_traits<boost::shared_ptr<T> > : std::iterator<void, T> { }; My point is: why don’t add an additional level of indirection for boost::lambda::detail::contentsof_type<> so that the indirection will allow the user to specialize it for smart pointers? -- Maxim Yegorushkin MetaCommunications Engineering http://www.meta-comm.com/engineering/

2 2

mpl::vector<void> compiler bugs?
by Larry Evans 23 Mar '04

23 Mar '04

The attached file gets following output: <-------------- cut here --------------- como -c --timing --long_long --display_error_number --diag_suppress 76 -I/home/evansl/prog_dev/boost-root.ln/boost_dev -I/home/evansl/prog_dev/boost-root.ln -o vec_void_const_bug.o vec_void_const_bug.cpp Comeau C/C++ 4.3.3 (Jan 30 2004 15:40:54) for LINUX_INTEL_ELF Copyright 1988-2004 Comeau Computing. All rights reserved. MODE:non-strict warnings C++ Front end time 0.76 (CPU) 1.00 (elapsed) Back end time 0.02 (CPU) 0.00 (elapsed) Total compilation time 0.78 (CPU) 1.00 (elapsed) como -o vec_void_const_bug.exe vec_void_const_bug.o running vec_void_const_bug ./vec_void_const_bug.exe mt_var: member_target(vector<void> const&) mt_con: mt_cast: member_target(vector<void> const&) end: >------------- cut here --------------------- When it should get the same output after mt_con: as it does for mt_var: and mt_cast:. I get similar problems with g++3.4 and intel 8.0. Are all these compilers wrong or am I missing something? TIA.

1 2

patch for STLport debug libs without stldebug-mode
by Ulrich Eckhardt 22 Mar '04

22 Mar '04

Hi! I discovered to my dismay that the boost_thread lib that uses STLport uses STLport's special debug mode. I therefore prepared a patch (against 1.31.0) that renames the current 'debug' target to 'stldebug' and adds a new 'debug' target that only uses the normal debug version of STLport. There are a few issues to discuss though: - I'm no expert of the build-system, not even an adept. I just tried to understand what's going on and tried until it seemed to work. It is a little tested on MSVC6. - I have no idea why the special debug-mode was introduced as default in the first place, I haven't found anything that tells why. - I found a note in one of the bbuild v2 files (which I did neither use nor patch) saying that 'normal debug' is not supported. Again, why and why isn't that stated in the notes for the *-stlport toolsets? - regex(IIRC) uses a 'd' in the resulting lib to mark debug libs and 'dd' to mark libs with special debug modes like STLport's. I adapted this naming convention when making the patch. In case anyone wonders, I work in an environment where I just don't have the extra time for STLport's debug mode. any comments welcome Ulrich Eckhardt

2 2

Re: [boost] Formal Review: Indexed Set
by JOAQUIN LOPEZ MU?Z 22 Mar '04

22 Mar '04

Hello Brian, thank you for reviewing indexed_set! ----- Mensaje original ----- De: Brian McNamara <lorgon(a)cc.gatech.edu> Fecha: Domingo, Marzo 21, 2004 1:00 am Asunto: Re: [boost] Formal Review: Indexed Set > > I read the "tutorial" and only glanced at the other sections. The > documentation is quite good. A few quick comments: > > Some of the code examples in the tutorial have lines longer than 80 > chars and they don't render well in my browser. Breaking the long > lines into multiple lines will easily fix this. > > At one point in the tutorial it says "nth_indexed_type" instead of > "nth_index_type". The same (extra "ed") bug is repeated again > shortly after the first one. Thank you, I'll fix these. > > I had to manually > #include "boost/indexed_set/sequenced_index.hpp" > in addition to > #include "boost/indexed_set.hpp" > in order to get "sequenced" to work. Not sure if this is a bug in > the docs or a bug in the library itself; either it should be included > automatically, or else the docs should mention including it manually. Well, this is not actually a bug, buy an issue I would like people to give their opinion about, along with other naming and organizatinal issues. If you feel in the mood, please take a look at the review notes at http://groups.yahoo.com/group/boost/files/indexed_set_review_notes.html Pavel has started an independent thread to treat these points. > > The docs mention > #define BOOST_INDEXED_SET_ENABLE_INVARIANT_CHECKING > for both "safe mode" and "invariant checking mode". I did not look > into this enough to decide if there is (or is supposed to be) a > different separate flag to set for "safe mode". > It's a bug in the docs. There exists a separate BOOST_INDEXED_SET_ENABLE_SAFE_MODE macro. Thank you for spotting this out. [...] > At one point, when using tags, I did something like > > struct by_seq {}; > ... sequenced<by_seq> ... // oops, should be > sequenced<tag<by_seq> > > > and got a compiler error. (BTW, the docs are not totally clear here; > they should say that you need tag<...>.) [...] Well, the requirement is stated at the referece, though it won't hurt to say it more explicitly in the tutorial. I'll try to improve this. > I noted with some dismay that duplicate tags are not detected. That > is, you are allowed to say > > struct by_id {}; > struct by_name {}; > struct by_foo {}; > typedef indexed_set< > employee, > index_list< > unique<tag<by_id,by_foo>,identity<employee> >, > > non_unique<tag<by_name,by_foo>, > member<employee,std::string,&employee::name> > > > > > employee_set; > > where I have named both indices "by_foo". I would prefer it if the > library detected this as a BOOST_STATIC_ASSERT-able error. > Currently, the approach is that the first index with a given tag is picked (the reference states this explicitly). I'm not convinced the approach you suggest is more convenient: maybe eliminating such duplicate tags in a metaprogramming environmnt (imagine the indexed_set is instantiated by an automatic framework) is not that simple. A static *warning* would be ideal here :) > > > 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. > > Yes. great ;) Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

3 2

[config] Patch for Intel 8.0 + Dinkum lib
by Gennaro Prota 22 Mar '04

22 Mar '04

Intel C++ for Windows never stops surprising me with its Microsoft bugtibility conundrums. When you use /Qms0 (version 8.0) it defines _MSC_VER to be 1200, as if it emulated VC++6! This tricks up the code in config/stdlib/dinkumware.hpp to define # define BOOST_NO_STD_USE_FACET # define BOOST_HAS_TWO_ARG_USE_FACET However the two-arg version of use_facet is deprecated and marked as such with __declspec(deprecated). Attached is an obvious patch to fix the problem. -- Genny. begin 644 dinkumpatch.txt M*BHJ(&1I;FMU;7=A<F4N:'!P+F]R:6<)5'5E($9E8B`@,R`Q,SHT,3HT-2`R M,#`T"BTM+2!D:6YK=6UW87)E+FAP<`E&<FD(a)36%R(#$R(#$X.C(W.C,T(#(P M,#0**BHJ*BHJ*BHJ*BHJ*BHJ"BHJ*B`R.2PS-B`J*BHJ"B`@(R`@("`@9&5F M:6YE($)/3U-47TY/7U-41%]!3$Q/0T%43U(-"B`@(R`@96YD:68-"B`@(R`@ M9&5F:6YE($)/3U-47TA!4U]005)424%,7U-41%]!3$Q/0T%43U(-"B$@(R`@ M:68@*&1E9FEN960H7TU30U]615(I("8F("A?35-#7U9%4B`\(#$S,#`I*2`F M)B`A9&5F:6YE9"A?7T)/4DQ!3D1#7U\I#0H@("`@("`@("\O(&EF('1H:7,@ M;&EB('9E<G-I;VX@:7,@<V5T('5P(&9O<B!V8S8@=&AE;B!T:&5R92!I<R!N M;R!S=&0Z.G5S95]F86-E=#H-"B`@(R`@("`@9&5F:6YE($)/3U-47TY/7U-4 M1%]54T5?1D%#150-"B`@(R`@("`@9&5F:6YE($)/3U-47TA!4U]45T]?05)' M7U5315]&04-%5`T*("`@("`@("`O+R!#(&QI8B!F=6YC=&EO;G,@87)E;B=T M(&EN(&YA;65S<&%C92!S=&0@96ET:&5R.@T*+2TM(#(Y+#,W("TM+2T*("`C M("`@("!D969I;F4@0D]/4U1?3D]?4U1$7T%,3$]#051/4@T*("`C("!E;F1I M9@T*("`C("!D969I;F4@0D]/4U1?2$%37U!!4E1)04Q?4U1$7T%,3$]#051/ M4@T*(2`C("!I9B`H9&5F:6YE9"A?35-#7U9%4BD@)B8@*%]-4T-?5D52(#P@ M,3,P,"D@)B8@0D]/4U1?24Y414Q?0UA87U9%4E-)3TX@/"`X,#`I("8F("%D M969I;F5D*%]?0D]23$%.1$-?7RD-"B`@("`@("`@+R\@:68@=&AI<R!L:6(@ M=F5R<VEO;B!I<R!S970@=7`@9F]R('9C-B!T:&5N('1H97)E(&ES(&YO('-T M9#HZ=7-E7V9A8V5T.@T**R`@("`@("`O+R`H8V%U=&EO;CH@26YT96P@."XP M(&9O<B!7:6X@=VET:"`O46US,"!D969I;F5S(%]-4T-?5D52('1O(&)E(#$R M,#`@8G5T(&ET(&ES(&YO="!60S8A*0T*("`C("`@("!D969I;F4@0D]/4U1? M3D]?4U1$7U5315]&04-%5`T*("`C("`@("!D969I;F4@0D]/4U1?2$%37U17 M3U]!4D=?55-%7T9!0T54#0H@("`@("`@("\O($,@;&EB(&9U;F-T:6]N<R!A @<F5N)W0@:6X@;F%M97-P86-E('-T9"!E:71H97(Z#0IB ` end

4 26

recommend logging library?
by Neal D. Becker 22 Mar '04

22 Mar '04

I notice boost doesn't have a logging library. I have seen several floating around. Are there any recommendations?

13 24

[fsm] Finally ...
by Andreas Huber 22 Mar '04

22 Mar '04

... has boost::fsm reached a reasonably stable state. Code, examples and documentation can be found here: http://boost-sandbox.sf.net/fsm.zip The documentation can also be browsed online: http://boost-sandbox.sf.net/libs/fsm Comments, questions, etc. are most welcome. Andreas Huber

1 0

[filesystem] relative_to
by John Torjo 22 Mar '04

22 Mar '04

Dear boosters, I noticed that currently there's no way to get the relative path of path A related to path B. What I mean is, given two **complete** paths, to get the relative path of one related to the other. To give a real example, I have an application that starts in directory initial_path(). I have several dialogs that allow the user to browse for files. My requirement is, after the user browses for a file, to internally ALWAYS store the path relative to initial_path(). Since there's no way to do this currently, I created my own function. Do you think it could be a useful addition to filesystem library? // converts the given path, making it relative to the src path // // precondition: dest & src are both complete path relative_to( const path & dest, const path & src) { // both paths should be complete assert( dest.is_complete() && src.is_complete() ); path::iterator dest_begin = dest.begin(), dest_end = dest.end(); path::iterator src_begin = src.begin(), src_end = src.end(); path result; #if defined(BOOST_WINDOWS) //#if defined(WIN32) if ( dest.root_name() != src.root_name() ) { // paths are on different drives (like, "c:/test/t.txt" and "d:/home") return dest; } if ( src_begin != src_end) ++src_begin; if ( dest_begin != dest_end) ++dest_begin; #endif // ignore directories that are same while ( (src_begin != src_end) && (dest_begin != dest_end)) { if ( *src_begin != *dest_begin) break; ++src_begin, ++dest_begin; } // now, we begin to relativize while ( src_begin != src_end) { result /= ".."; ++src_begin; } while ( dest_begin != dest_end) { result /= *dest_begin; ++dest_begin; } return result; } void test_relative_to( const std::string & dest, const std::string & src) { std::string result = relative_to( dest, src).string(); std::cout << "Testing path '" << dest << "',\n" " relative to '" << src << "'\n" " result : '" << result << "'\n" << std::endl; } int main(int argc, char* argv[]) { path::default_name_check( &native); test_relative_to( "c:/temp/test/inner/i2/file.txt", "c:/temp/test"); test_relative_to( "c:/temp/test/inner/i2/file.txt", "c:/temp/test/other"); test_relative_to( "c:/temp/test/inner/i2/file.txt", "c:/temp"); test_relative_to( "c:/temp/test/inner/i2/file.txt", "c:/temp/test"); test_relative_to( "c:/temp/test", "c:/temp/test"); test_relative_to( "c:/temp/test/inner/i2/file.txt", "d:/temp/test"); test_relative_to( "c:/temp/test", "d:/temp/test"); test_relative_to( "c:/other/test/inner/i2/file.txt", "c:/temp/test"); test_relative_to( "c:/other/test/inner/i2/file.txt", "c:/oth/test/other"); test_relative_to( "c:/other/test/inner/i2/file.txt", "c:/temp"); test_relative_to( "c:/other/test/inner/i2/file.txt", "c:/other/test"); return 0; } Best, John

2 2

Using Serialization for binary marshalling
by Matthew Vogt 22 Mar '04

22 Mar '04

Is anyone else interested in using Robert Ramey's serialization library for the purpose of marshalling data into pre-determined binary formats? This is not related to serialization in a general sense, but employing the syntax and underlying fundamentals of the library, to a somewhat related purpose. This is a test program demonstrating what I'm doing - I'm interested to know if anyone else is doing anything similar... Matt test.cpp: ------------------------------------------------------------------ #include <sstream> #include <cassert> #include "marshall.hpp" #include "network_oarchive.hpp" #include "network_iarchive.hpp" class test { struct subobject; // Basic fixed-size primitives uint8_t a; uint16_t b; uint32_t c; uint64_t d; // String data that must be serialized to a pre-determined length marshall::fixed_length<std::string, 20> e; marshall::fixed_length<std::wstring, 10> f; // String data that must be serialized with a prepended length // (whose size is itself predetermined) marshall::variable_length<std::string, uint8_t> g; marshall::variable_length<std::wstring, uint8_t> h; // Arbitrary data that must be serialized to a pre-determined length marshall::fixed_length<std::vector<uint16_t>, 5> i; marshall::fixed_length<std::vector<subobject>, 2> j; // Arbitrary data that must be serialized with a prepended length // (whose size is itself predetermined) marshall::variable_length<std::vector<uint16_t>, uint32_t> k; marshall::variable_length<std::vector<char>, uint32_t> l; // A sub-object of arbitrary complexity struct subobject { subobject(void) : a(0), b(0) {} subobject(uint32_t x, uint32_t y) : a(x), b(y) {} bool operator== (const subobject& other) const { return (a == other.a && b == other.b); } private: uint32_t a; uint32_t b; friend class boost::serialization::access; template <class Archive> void serialize(Archive& archive, const unsigned version) { archive & a & b; } }; friend class boost::serialization::access; template <class Archive> void serialize(Archive& archive, const unsigned version) { archive & a & b & c & d & e & f & g & h & i & j & k & l; } public: test(void) : a(0x01), b(0x0203), c(0x04050607), d(0x08090a0b0c0d0e0f), e("abcdefg"), g("xyz") { f[0] = 'A'; f[1] = 'B'; f[2] = 'C'; h.push_back('w'); i[0] = 255; i[1] = 254; i[2] = 253; j[0] = subobject(99, 100); k.push_back(1); k.push_back(2); k.push_back(3); l.push_back('l'); } test(bool) {} // Don't initialize everything bool operator== (const test& other) const { return (a == other.a && b == other.b && c == other.c && d == other.d && e == other.e && f == other.f && g == other.g && h == other.h && i == other.i && j == other.j && k == other.k && l == other.l); } }; int main(int, char**) { test t1; // Serialize object to binary format, in network byte order std::ostringstream oss; boost::archive::network_oarchive oa(oss); oa << t1; // Create uninitialized object test t2(false); // De-serialize object from binary format, in network byte order std::istringstream iss(oss.str()); boost::archive::network_iarchive ia(iss); ia >> t2; assert(t1 == t2); return 0; } This produces the following binary output: ------------------------------- 0000000 |01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 61 |a |b |c |d |e 0000020 |62 63 64 65 66 67 00 00 00 00 00 00 00 00 00 00 | 0000040 |00 00 00 00 00 00 41 00 00 00 42 00 00 00 43 00 | | f 0000060 |00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 0000100 |00 00 00 00 00 00 00 00 00 00 00 03 78 79 7a 01 | |g |h 0000120 |00 00 00 77 00 ff 00 fe 00 fd 00 00 00 00 00 00 | |i |j 0000140 |00 63 00 00 00 64 00 00 00 00 00 00 00 00 00 00 | |k 0000160 |00 03 00 01 00 02 00 03 00 00 00 01 6c | |l

3 4

BOOST_PP_COMMA, LPAREN,RPAREN delay eval?
by Larry Evans 22 Mar '04

22 Mar '04

I've looked at some of the uses of these, but can't figure out how to do the following. Using boost/preprocessor macros, I want to generate code something like: #include <boost/mpl/vector.hpp> #include <boost/mpl/at.hpp> using namespace boost::mpl; struct source { target my_target ; template<typename VecOfTypes> source ( VecOfTypes const& , at_c<VecOfTypes,0>::type a0 ) : my_target ( a0 ) {} template<typename VecOfTypes> source ( VecOfTypes const& , at_c<VecOfTypes,0>::type a0 , at_c<VecOfTypes,1>::type a1 ) : my_target ( a0 , a1 ) {} }; and use it as follows: typedef vector<int,float> int_float_typelist; source s0(int_float_typelist(),0); source s1(int_float_typelist(),0,2.5); I was planning on defining a macro, PP_CTOR_FORWARDER_OVERLOAD, to be used as: struct source { BOOST_PP_REPEAT(2,PP_CTOR_FORWARDER_OVERLOAD,(source, my_target)) }; However, I also would like to use it where instead of my_target(a0,a1), there might be super_type(new target(a0,a1)), in which case the tuple that was the last arg to BOOST_PP_REPEAT would contain left and right parens. However, when I tried: BOOST_PP_REPEAT( 2, PP_CTOR_FORWARDER_OVERLOAD, (source,auto_ptr<target> BOOST_PP_LPAREN() new target, BOOST_PP_RPAREN() )) I get: /usr/local/gcc-3.4-20040225/bin/g++ -ggdb -c -Wall -MMD -O0 -ggdb -E -I/home/evansl/prog_dev/boost-root.ln/boost_dev -I/home/evansl/prog_dev/boost-root.ln pp_ctor_forwarder.cpp |indent -st pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_0" requires 4 arguments, but only 2 given pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_1" requires 4 arguments, but only 2 given pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_2" requires 4 arguments, but only 2 given pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_0" requires 4 arguments, but only 2 given pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_1" requires 4 arguments, but only 2 given pp_ctor_forwarder.cpp:4:1: macro "BOOST_PP_TUPLE_ELEM_4_2" requires 4 arguments, but only 2 given # 1 "pp_ctor_forwarder.cpp" How can I cause the delay in evaluation of BOOST_PP_RPAREN and LPAREN to avoid these errors? Here is my current macro def: #include "boost/preprocessor/enum_params.hpp" #include "boost/preprocessor/inc.hpp" #include "boost/preprocessor/punctuation/comma_if.hpp" #include "boost/preprocessor/tuple/elem.hpp" #define PP_CTOR_FORWARDER_PARAM(z,n,_) \ BOOST_PP_COMMA_IF(n) at_c<VecOfTypes,n>::type BOOST_PP_CAT(a,n) #define PP_CTOR_FORWARDER_OVERLOAD(z,n,data) \ template< typename VecOfTypes > \ BOOST_PP_TUPLE_ELEM(4,0,data) \ ( VecOfTypes const& \ , BOOST_PP_REPEAT(BOOST_PP_INC(n), PP_CTOR_FORWARDER_PARAM, BOOST_PP_EMPTY) \ ) \ : BOOST_PP_TUPLE_ELEM(4,1,data) \ BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), a ) \ BOOST_PP_TUPLE_ELEM(4,2,data) \ {} TIA.

2 3