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

boost program_options "count" question
by F David Sacerdoti 24 Aug '07

24 Aug '07

As per Volodya's suggestion, posting this question here. He mentioned it had been discussed, but I was unable to find anything appropriate using search engines. I apologize in advance if this is a repeat question. Hi, I am trying to do a simple thing with your program_options boost library: I have a program foo, and I want to invoke it like this: foo -d -d -d I want foo to know "I have counted three -d". I followed your tutorial and tried this: desc.add_options() ("debug,d",po::value< vector<int> >()->default_value(1), "Debug level") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("debug")) { cout << "Running, debug level: " << vm["debug"].as< vector<int> >().size() << "\n"; } But it did not work, always prints "debug level: 0". For background, this is to make the program compatible with a Python implementation which uses optparse. I have an extensive testing framework that assumes this behavior and it would be nice to implement the same with program_options. Thanks, Federico

3 4

error C2976 in python tutorial?
by Guido Ziliotti 24 Aug '07

24 Aug '07

Probably Has anybody faced error C2976: 'boost::python::class_' : too few template arguments? Compiler msvc-8.0. BOOST_PYTHON_MODULE(hello){ class_<World>("World") .def("greet", &World::greet) .def("set", &World::set) ; } produced that. Source code follows. #include <string> char const* greet() { return "hello, world"; } struct World { void set(std::string msg) { this->msg = msg; } std::string greet() { return msg; } std::string msg; }; #include <boost/python/module.hpp> #include <boost/python/def.hpp> using namespace boost::python; //nota che la funzione globale va prima BOOST_PYTHON_MODULE(hello) { def("greet", greet); class_<World>("World") .def("greet", &World::greet) .def("set", &World::set) ; }

1 0

[test] Uncaught exception in BOOST_CHECK_THROW() causing SIGABRT
by Richard Dingwall 24 Aug '07

24 Aug '07

Hi there, I thought I'd post this because A) it might save someone a lot of head-scratching and B) there aren't any posts on it already. The short of it is, that if you have a setup similar to the following (i.e., an empty throw() clause on a template specialisation): template<class output_type> output_type do_something(int input_value) throw(std::invalid_argument); template<> int do_something(int input_value) throw(std::invalid_argument); template<> long do_something(int input_value) throw(); And attempt to test throwing a std::invalid_argument from within the long specialised function, e.g.: // note: an argument less than zero will throw a std::invalid_argument BOOST_CHECK_THROW(do_something<long>(-1), std::invalid_argument); You will see something the following: Running 4 test cases... terminate called after throwing an instance of 'std::invalid_argument' what(): Input value too low. unknown location(0): fatal error in "long_throw": signal: SIGABRT (application abort requested) sigabrt_test_suite.cpp(58): last checkpoint *** 1 failure detected in test suite "sigabrt tests" My function is throwing a std::invalid_argument and my test case been programmed to catch it. But it doesn't. This had me scratching my head for a few days, until I noticed the empty throw() clause. Completing it resolved the problem immediately. I'm not sure if this is expected behaviour, but if anyone's interested, a test case is attached. I'm using gcc version 4.0.1 (Apple Computer, Inc. build 5367) on a G4 Powerbook with whatever was in Boost's SVN trunk on August 6. Cheers, Richard

2 1

Multi Array Question
by chris dion 24 Aug '07

24 Aug '07

Hi I'm having a problem with the boost/multi_array and I'm hoping someone here can help, or at least explain why the following doesn't work. The problem: I have a multi_array of ints that I want to be able to view as being either row major or column major to simplify a number algorithms. I don't want to change the internal representation of the array (the default c++ row major storage layout is fine), I just want to be able to interchange the indexing order from array[row][col] to array[col][row] for the same multi_array. To do so, I attempted to define 2 array_views of the same multi_array with different stride values, like this: #include <iostream> using namespace std; #include <boost/multi_array.hpp> using namespace boost; int main(void) { typedef multi_array<int, 2> intarray2; typedef intarray2::array_view<2>::type intarray2view2; typedef intarray2::array_view<1>::type intarray2view1; typedef intarray2::index_range intarray2range; intarray2 arr(extents[3][3]); // test data int a = 0; for (int r = 0; r < 3; r++) { for (int c = 0; c < 3; c++) { arr[r][c] = a++; } } intarray2view2 rows = arr[indices[intarray2range().stride(3)][intarray2range().stride(1)]]; intarray2view2 cols = arr[indices[intarray2range().stride(1)][intarray2range().stride(3)]]; /* 0 1 2 3 4 5 6 7 8 */ cout << rows[2][1]; // i expect this to print 7 cout << cols[2][1]; // i expect this to print 5 } Unfortunately, this doesn't work at all (an assert fails when indexing the views). I debugged (using Visual C 2005), and found that the 'rows' array_view has a stride collection of [9, 1], while the 'cols' array_view stride collection is [3, 3]. Both are different than what I specified during construction. It appears that they're being multiplied by the extents of the first dimension of the multi_view array (in this example: 3). I can produce a column major view of a single column of the array using a 1 dimensional view constructed using a degenerate range, like this: intarray2view1 col= arr[indices[1][intarray2range()]]; // column 1 in arr but that's not what I'm hoping to achieve. Can someone explain the behavior above and/or suggest a way of creating a 2d column major array_view of a 2d multi_array? Thanks - Chris Dion _________________________________________________________________ Show Your Messenger Buddies How You Really Feel http://www.freemessengeremoticons.ca/?icid=EMENCA122

2 1

Construction/assignment inconsistency with boost::function on MSVC2005
by Josef Grahn 23 Aug '07

23 Aug '07

Hello, I encountered the following inconsistency constructing a boost::function object from a pointer to a template function. template <typename T> void foo(T) {} int main(int argc, char **argv) { boost::function<void (int)> f1; f1 = foo<int>; boost::function<void (int)> f2 = foo<int>; f1(0); // ok f2(0); // error, function pointer is zero! return 0; } I am compiling on MSVC2005 SP1, using boost version 1.34.1. It seems to work properly with GCC 4.1.2 and boost 1.33.1 on Ubuntu, however. Is this a known problem? Best Regards, Josef Grahn

3 2

Re: [Boost-users] [boost] ScopeExit Review Begins Today
by Jody Hagins 23 Aug '07

23 Aug '07

The discussion threads included comments from several people who did not offer an actual review and/or YES/NO. I have filtered every message with either scope or exit in the subject, and I want to make sure I have all the reviews. If your name is in this list, that means I have a YES/NO review from you. Otherwise, I may see some discussion from you, but no YES/NO review. If your name is NOT in this list, but you feel you provided a review, please point me to your review posting, or provide appropriate clarification. The fact that you participated in the discussion does not mean that I know your opinion on the acceptance of ScopeExit. In addition, I have received a few reviews via private email. For the sake of fairness and openness, I asked the authors to send their review to the list. I will not consider them unless they appear in the open mailing list. Thanks for your cooperation! Kim Barrett Aaron LaFramboise Steven Watanabe Ben Kuppers Andrey Semashev Peder Holt Goran Mitrovic Johan Nilsson Pavel Vozenilek Tom Brinkman Maxim Yanchenko

1 0

Re: [Boost-users] [boost] ScopeExit Review Begins Today
by Jody Hagins 23 Aug '07

23 Aug '07

Thanks for all the input on Alexander's ScopeExit submission. There are some good discussions, so please continue them over the next day or so if necessary. I am very busy this weekend (I am HC of a high school football team, and our first game is tomorrow night), but I will render a conclusion some time next week. Again, thanks for the input.

1 0

ptr_container problem
by Aljaz 23 Aug '07

23 Aug '07

Hello I'm trying to use ptr_vector but I'm having headaches because I have no idea why I'm getting this error: error C2248: 'boost::ptr_container_detail::reversible_ptr_container<Config,CloneAllocator>::operator =' : cannot access private member declared in class 'boost::ptr_container_detail::reversible_ptr_container<Config,CloneAllocator>' with [ Config=boost::ptr_container_detail::sequence_config<boost::asio::dns::base_nameserver_resource,std::vector<void *,std::allocator<void *>>>, CloneAllocator=boost::heap_clone_allocator ] C:\Program Files\boost\boost_1_34_0\boost/ptr_container/detail/reversible_ptr_container.hpp(287) : see declaration of 'boost::ptr_container_detail::reversible_ptr_container<Config,CloneAllocator>::operator =' with [ Config=boost::ptr_container_detail::sequence_config<boost::asio::dns::base_nameserver_resource,std::vector<void *,std::allocator<void *>>>, CloneAllocator=boost::heap_clone_allocator ] This diagnostic occurred in the compiler generated function 'boost::ptr_sequence_adapter<T,VoidPtrSeq,CloneAllocator> &boost::ptr_sequence_adapter<T,VoidPtrSeq,CloneAllocator>::operator =(const boost::ptr_sequence_adapter<T,VoidPtrSeq,CloneAllocator> &)' with [ T=boost::asio::dns::base_nameserver_resource, VoidPtrSeq=std::vector<void *,std::allocator<void *>>, CloneAllocator=boost::heap_clone_allocator ] My code (simplified): class base1 { public: void somefunc() { }; }; class main : public base1 { public: virtual void somefunc() { } }; class derived : public main { public: virtual void somefunc() { } }; boost::ptr_vector<main> m_vector; Any Idea what am I doing wrong? I tried to add do_clone functions/members without success. Any help is highly appreciated Regards A

2 1

ScopeExit Review ends tomorrow (Wednesday)
by Jody Hagins 23 Aug '07

23 Aug '07

The ScopeExit review ends on Wednesday, August 22. If you want to have input on its acceptance into Boost, please provide a review by tomorrow. BTW, we need more input ;-) Thanks! >From the original announcement... The review period for Scope Exit Time Series, submitted by Alexander Nasonov, runs from Monday, August 13 until Wednesday, August 22. >From the documentation: Nowadays, every C++ developer is familiar with RAII technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. But there are times when writing a special class for such variable is not worth the effort. This is when ScopeExit macro comes into play. You put resource acquisition directly in your code and next to it you write a code that releases the resource. Note that ScopeExit uses PP macros and relies on Boost.Typeof. The latest version can is here: http://boost-consulting.com/vault/index.php?action=downloadfile&filename=sc… It's available also at http://tinyurl.com/2z6qg2 Online documentation is here: http://194.6.223.221/~nasonov/scope_exit-0.04/libs/scope_exit/doc/html/inde… >From the review guidelines here: http://boost.org/more/formal_review_process.htm ... Boost mailing list members are encouraged to submit Formal Review comments: * Publicly on the mailing list. * Privately to the Review Manager. Private comments to a library submitter may be helpful to her or him, but won't help the Review Manager reach a decision, so the other forms are preferred. What to include in Review Comments Your comments may be brief or lengthy, but basically the Review Manager needs your evaluation of the library. If you identify problems along the way, please note if they are minor, serious, or showstoppers. 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. Thanks in advance to every for your participation in this review. _______________________________________________ Boost-users mailing list Boost-users(a)lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

3 5

Boost fixed point data type or other support for monetary values?
by Jeff Dunlap 23 Aug '07

23 Aug '07

Hello, I'm having some rounding problems using the double data type on some financial calculations. Does Boost have a fixed point data type or is there other functionality that may be helpful to me? Any suggestions would also be appreciated. Thanks very much

1 0

basic file io in boost 1_34_1. A compilable 'hello world' example for large (>2^31byte) files?
by Peter Leopold 23 Aug '07

23 Aug '07

Dear Boost Users, I've used boost on and off for years for its string parsing. Now I'd like to use it to replace std::ifstream for file reading. The immediate requirement is a file > 2^31 bytes. Since my requirement is to replace ifstream, I was hoping for a fairly simple transition, perhaps even something I could manage with an emacs global search-and-replace. I started with kubuntu-feisty's boost 1.33.1. but was unable to execute the first main in the iostreams tutorial Overview (2.1.1). The showstopper was the compiler error <file_sink> not defined in scope. % g++ test.cpp test.cpp: In functin 'int main()': test.cpp::9: error: 'file_sink' was not declared in this scope . . . several more errors. This is an error without precedent, at least according to google. Thinking this is a kubuntu-apt-get issue, I downloaded and rebuilt and installed boost 1_34_1 from scratch. Alas, <file_sink> is still not declared. Am I doing something obvious wrong? I'm using g++ 4.1.2. Does anyone have a few lines of code that will * open a file? * seekg() to the beginning, end and arbitrary location in the file? * tellg() the present file pointer location in the file? * read(address, number of bytes) from the file? These are the basic STL features I'm trying to replace. Many thanks for any pointers to useful documentation (but not to boost.org/libs/iostreams/doc/index.html, please) or code snippets. Once I have my "hello world" working, I might start making sense of <file_sink> templated streams, and why my install can't find <file_sink> when it is sitting right there in <boost/iostreams/device/file.hpp>!?!? -- Peter Leopold Peter dot Leopold at BioAnalyte dot com <http://www.bioanalyte.com>

2 1

Bad Lexical_Cast!
by Frame Buffer 22 Aug '07

22 Aug '07

Hello! I am trying to compile the following program from *Beyond the C++ Standard Library: An Introduction to Boost. *Here is the source code: #include <iostream> #include <string> #include "boost/lexical_cast.hpp" class lexical_castable { public: lexical_castable() { }; lexical_castable(const std::string s) : s_(s) { }; friend std::ostream& operator<<(std::ostream& o, const lexical_castable& le); friend std::istream& operator>>(std::istream& i, lexical_castable& le); private: virtual void print_(std::ostream& o) const; void read_( std::istream& i ); std::string s_; }; std::ostream& operator<<(std::ostream& o, const lexical_castable& le) { le.print_(o); return o; } std::istream& operator>>(std::istream& i, lexical_castable& le) { le.read_(i); return i; } void lexical_castable::read_( std::istream& i ) { i >> s_; } void lexical_castable::print_( std::ostream& o ) const { o << s_ <<"\n"; } int main(int argc, char* argv[]) { lexical_castable le(); std::cin >> le; int i=0; try { i = boost::lexical_cast<int>(le); std::cout << i << '\n'; } catch(boost::bad_lexical_cast &e) { std::cout << e.what() << '\n'; std::cout << "You were supposed to enter a number!\n"; } } The lexical_cast is throwing an exception as follows: boost::bad_lexical_cast::what returned 0x004c9888 "bad lexical cast: source type value could not be interpreted as target" const char * Note that I have modified the original code a bit because I was trying to figure out what went wrong. The object le is getting created successfully with the user entered "number" getting stored in the string s_ Please help. I am using Visual studio 2005 with boost v1.34

2 1

program options
by Stefan Bradl 22 Aug '07

22 Aug '07

Hello, I am using boost::program_options and need to load custom config files. So I think I need to write a parser, right? But I did not find any tutorials or something like that where I can learn how to write and usea parser with program options. Can anybody help me out og this problem? Thx in advance

2 3

boost::serialization throwing bad_alloc
by Fletcher, Matthew (Information Technology) 22 Aug '07

22 Aug '07

Hi all, I am suffering from boost serialization throwing a bad_alloc exception at a very low-level that I've been unable to explain or workaround. I first hit the problem on 1_33 but upgrading to 1_34 and then 1_34_1 had no effect. My code is within one DLL and I'm loading boost dynamically through the DLLs. This is a real-showstopper for me - any suggestions at all gratefully received. Thanks, Matt. The disassembly from save_access::save_primitive: ar.save(t); 488FEC20 mov esi,esp 488FEC22 mov eax,dword ptr [t] 488FEC25 push eax 488FEC26 mov ecx,dword ptr [ar] 488FEC29 add ecx,8 488FEC2C call dword ptr [__imp_boost::archive::basic_binary_oprimitive<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save (48EBA254h)] 488FEC32 cmp esi,esp 488FEC34 call @ILT+121865(__RTC_CheckEsp) (487A9C0Eh) } The debugger cursor points to the cmp line so I believe the exception is being thrown by the __imp_boost call. For what it's worth esi = 1301555968 and esp = 1301555820 and t is an innocuous looking string of size 5135. My top level calling code: std::ostringstream os; boost::archive::binary_oarchive oa( os ); oa << BOOST_SERIALIZATION_NVP( pMyClass ); where pMyClass has been passed as: const myClass * pMyClass Both my top-level class and all intermediate ones have the same standard serialization structure: class myClass : public boost::noncopyable { ... private: myClass(){}; friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & BOOST_SERIALIZATION_NVP( ... ) ... } } Full stack dump: kernel32.dll!7c812a5b() kernel32.dll!7c812a5b() msvcr71d.dll!47ce9504() msvcr71d.dll!47ce94fb() msvcr71d.dll!47cebed9() msvcr71d.dll!47d06fa9() msvcp71d.dll!47dd8946() msvcp71d.dll!47ddd05f() msvcp71d.dll!47d8a97c() msvcp71d.dll!47d890b2() msvcp71d.dll!47db4b55() msvcp71d.dll!47d8accc() msvcp71d.dll!47d994ca() msvcp71d.dll!47d994ca() boost_serialization-vc71-mt-gd-1_34_1.dll!47f4ae67() msvcp71d.dll!47d870bf() boost_serialization-vc71-mt-gd-1_34_1.dll!47f4abf1() > myDLL.dll!boost::archive::save_access::save_primitive<boost::archive::bi nary_oarchive,std::basic_string<char,std::char_traits<char>,std::allocat or<char> > >(boost::archive::binary_oarchive & ar={...}, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & t={...}) Line 91 + 0x12 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::basic_string<char,std::char_traits<char>,std::alloc ator<char> > >::save_primitive::invoke(boost::archive::binary_oarchive & ar={...}, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & t={...}) Line 244 + 0xd C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::basic_string<char,std::char_traits<char>,std::alloc ator<char> > >::invoke(boost::archive::binary_oarchive & ar={...}, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,std::basi c_string<char,std::char_traits<char>,std::allocator<char> > >(boost::archive::binary_oarchive & ar={...}, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<std::basic_string<char,std::char_traits<char>,st d::allocator<char> > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<std::basic_string<char,std::char_tra its<char>,std::allocator<char> > const >::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<std::basic_string<char,std::char_t raits<char>,std::allocator<char> > const > const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<std::basic_string<char,std::char_ traits<char>,std::allocator<char> > const > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<std::basic_string<char,std::char_traits<c har>,std::allocator<char> > const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<std::basic_string<char,std::char_tra its<char>,std::allocator<char> > const >::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<std::basic_string<char,std::char_tra its<char>,std::allocator<char> > const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<std::basic_string<char,std::char_traits<char >,std::allocator<char> > const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<std::basic_string<char,std::char_traits< char>,std::allocator<char> > const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::basic_string<char,std::ch ar_traits<char>,std::allocator<char> > const > >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::basic_string<char,std::ch ar_traits<char>,std::allocator<char> > const > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > const > >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::basic_string<char,std::char_traits<char>, std::allocator<char> > const > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<std::basic_string<ch ar,std::char_traits<char>,std::allocator<char> > const > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<std::basic_string<char ,std::char_traits<char>,std::allocator<char> > const > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<std::basic_string<char,std::c har_traits<char>,std::allocator<char> > const > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<std::basic_string<ch ar,std::char_traits<char>,std::allocator<char> > const > const >() Line 80 C++ myDLL.dll!boost::serialization::stl::save_collection<boost::archive::bin ary_oarchive,std::vector<std::basic_string<char,std::char_traits<char>,s td::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & s={...}) Line 59 C++ myDLL.dll!boost::serialization::save<boost::archive::binary_oarchive,std ::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > >(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}, const unsigned int __formal=0) Line 41 + 0xd C++ myDLL.dll!boost::serialization::free_saver<boost::archive::binary_oarchi ve,std::vector<std::basic_string<char,std::char_traits<char>,std::alloca tor<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}, const unsigned int file_version=0) Line 45 + 0x18 C++ myDLL.dll!boost::serialization::split_free<boost::archive::binary_oarchi ve,std::vector<std::basic_string<char,std::char_traits<char>,std::alloca tor<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >(boost::archive::binary_oarchive & ar={...}, std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}, const unsigned int file_version=0) Line 74 + 0x11 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > >(boost::archive::binary_oarchive & ar={...}, std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}, const unsigned int file_version=0) Line 68 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,std::vector<std::basic_string<char,std::char_traits<char>,std::all ocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >(boost::archive::binary_oarchive & ar={...}, std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::oserializer<boost::archive::binary_oar chive,std::vector<std::basic_string<char,std::char_traits<char>,std::all ocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::save_object_data(boost::archive::detail::basic_oarchive & ar={...}, const void * x=0x4da09810) Line 151 + 0x2b C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a2bb() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa3e() myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::vector<std::basic_string<char,std::char_traits<char >,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::save_standard::invoke(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}) Line 263 + 0x15 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::vector<std::basic_string<char,std::char_traits<char >,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,std::vect or<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >(boost::archive::binary_oarchive & ar={...}, const std::vector<std::basic_string<char,std::char_traits<char>,std::allocator <char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<std::vector<std::basic_string<char,std::char_tra its<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<std::vector<std::basic_string<char,std::char_traits<cha r>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<std::vector<std::basic_string<char,s td::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<std::vector<std::basic_string<char ,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<std::vector<std::basic_string<cha r,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<std::vector<std::basic_string<char,std::c har_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<std::vector<std::basic_string<char,s td::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > >::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<std::vector<std::basic_string<char,s td::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<std::vector<std::basic_string<char,std::char _traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<std::vector<std::basic_string<char,std:: char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::vector<std::basic_string< char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::vector<std::basic_string< char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<std::vector<std::basic_string<char,std::char_traits<cha r>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::vector<std::basic_string<char,std::char_t raits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<std::vector<std::bas ic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<std::vector<std::basic _string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<std::vector<std::basic_string <char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<std::vector<std::bas ic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >() Line 80 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator&<boost::serialization::nvp<std::vector<std::basi c_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allo cator<char> > > > > const >() Line 91 C++ myDLL.dll!myNS::myComponentClass::serialize<boost::archive::binary_oarch ive>() Line 90 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,myNS::myFunc>(boost::archive::binary_oarchive & ar={...}, myNS::myFunc & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,myNS::myFunc>(boost::archive::binary_oarchive & ar={...}, myNS::myFunc & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,myNS::myFunc>(boost::archive::binary_oarchive & ar={...}, myNS::myFunc & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::oserializer<boost::archive::binary_oar chive,myNS::myFunc>::save_object_data(boost::archive::detail::basic_oarc hive & ar={...}, const void * x=0x4da097d8) Line 151 + 0x2b C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a1de() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa3e() myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,myNS::myFunc>::save_standard::invoke(boost::archive::bin ary_oarchive & ar={...}, const myNS::myFunc & t={...}) Line 263 + 0x15 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,myNS::myFunc>::invoke(boost::archive::binary_oarchive & ar={...}, const myNS::myFunc & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,myNS::myF unc>(boost::archive::binary_oarchive & ar={...}, const myNS::myFunc & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<myNS::myFunc const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<myNS::myFunc const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<myNS::myFunc const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<myNS::myFunc const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<myNS::myFunc>::save<boost::archive:: binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<myNS::myFunc> const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<myNS::myFunc> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<myNS::myFunc> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<myNS::myFunc>::serialize<boost::arch ive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<myNS::myFunc> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<myNS::myFunc> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<myNS::myFunc> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc> & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myFunc> >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc> & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myFunc> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc> & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<myNS::myFunc> >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc> & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<myNS::myFunc> const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<myNS::myFunc> const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<myNS::myFunc> const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<myNS::myFunc> const >() Line 80 C++ myDLL.dll!boost::archive::detail::pointer_oserializer<myNS::myFunc,boost ::archive::binary_oarchive>::save_object_ptr(boost::archive::detail::bas ic_oarchive & ar={...}, const void * x=0x4da097d8) Line 216 C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a868() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa6e() myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myFunc *>::polymorphic<myNS::myFunc>::save(boost::archive::binary_oarchive & ar={...}, const myNS::myFunc & t={...}, const boost::archive::detail::basic_pointer_oserializer * bpos_ptr=0x48eaf914) Line 401 + 0x13 C++ myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myFunc *>::save<myNS::myFunc>(boost::archive::binary_oarchive & ar={...}, const myNS::myFunc & t={...}, const boost::archive::detail::basic_pointer_oserializer * bpos_ptr=0x48eaf914) Line 438 + 0x11 C++ myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myFunc *>::invoke(boost::archive::binary_oarchive & ar={...}, myNS::myFunc * const t=0x4da097d8) Line 466 + 0x11 C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,myNS::myF unc *>(boost::archive::binary_oarchive & ar={...}, myNS::myFunc * const & t=0x4da097d8) Line 535 + 0xf C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<myNS::myFunc * const>() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<myNS::myFunc * const>() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<myNS::myFunc * const>() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<myNS::myFunc * const>() Line 80 C++ myDLL.dll!boost::serialization::nvp<myNS::myFunc *>::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<myNS::myFunc *> const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<myNS::myFunc *> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<myNS::myFunc *>::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myFunc *> >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc *> & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myFunc *> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc *> & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myFunc *> & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<myNS::myFunc *> const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<myNS::myFunc *> const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<myNS::myFunc *> const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<myNS::myFunc *> const >() Line 80 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator&<boost::serialization::nvp<myNS::myFunc *> const >() Line 91 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,myNS::Date const ,myNS::myFunc *>(boost::archive::binary_oarchive & ar={...}, std::pair<myNS::Date const ,myNS::myFunc *> & p={...}, const unsigned int __formal=0) Line 42 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,std::pair<myNS::Date const ,myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, std::pair<myNS::Date const ,myNS::myFunc *> & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::oserializer<boost::archive::binary_oar chive,std::pair<myNS::Date const ,myNS::myFunc *> >::save_object_data(boost::archive::detail::basic_oarchive & ar={...}, const void * x=0x4da28df4) Line 151 + 0x2b C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a2bb() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa3e() myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::pair<myNS::Date const ,myNS::myFunc *> >::save_standard::invoke(boost::archive::binary_oarchive & ar={...}, const std::pair<myNS::Date const ,myNS::myFunc *> & t={...}) Line 263 + 0x15 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::pair<myNS::Date const ,myNS::myFunc *> >::invoke(boost::archive::binary_oarchive & ar={...}, const std::pair<myNS::Date const ,myNS::myFunc *> & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,std::pair <myNS::Date const ,myNS::myFunc *> >(boost::archive::binary_oarchive & ar={...}, const std::pair<myNS::Date const ,myNS::myFunc *> & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<std::pair<myNS::Date const ,myNS::myFunc *> const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<std::pair<myNS::Date const ,myNS::myFunc *> const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<std::pair<myNS::Date const ,myNS::myFunc *> const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<std::pair<myNS::Date const ,myNS::myFunc *> const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const >::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const >::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<std::pair<myNS::Date const ,myNS::myFunc *> const > const >() Line 80 C++ myDLL.dll!boost::serialization::stl::save_collection<boost::archive::bin ary_oarchive,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & s={...}) Line 59 C++ myDLL.dll!boost::serialization::save<boost::archive::binary_oarchive,myN S::myFunc *,myNS::Date,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > >(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}, const unsigned int __formal=0) Line 41 + 0xd C++ myDLL.dll!boost::serialization::free_saver<boost::archive::binary_oarchi ve,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::invoke(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}, const unsigned int file_version=0) Line 45 + 0x18 C++ myDLL.dll!boost::serialization::split_free<boost::archive::binary_oarchi ve,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >(boost::archive::binary_oarchive & ar={...}, std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}, const unsigned int file_version=0) Line 74 + 0x11 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,myNS::myFunc *,myNS::Date,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > >(boost::archive::binary_oarchive & ar={...}, std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}, const unsigned int file_version=0) Line 70 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >(boost::archive::binary_oarchive & ar={...}, std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::oserializer<boost::archive::binary_oar chive,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::save_object_data(boost::archive::detail::basic_oarchive & ar={...}, const void * x=0x4d808784) Line 151 + 0x2b C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a2bb() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa3e() myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::save_standard::invoke(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}) Line 263 + 0x15 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::invoke(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,std::map< myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >(boost::archive::binary_oarchive & ar={...}, const std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > >::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFu nc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<std::map<myNS::Date,myNS::myFu nc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<std::map<myNS::Date,myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<std::map<myNS::Date, myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<std::map<myNS::Date,my NS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<std::map<myNS::Date,myNS::myF unc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<std::map<myNS::Date, myNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >() Line 80 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator&<boost::serialization::nvp<std::map<myNS::Date,m yNS::myFunc *,std::less<myNS::Date>,std::allocator<std::pair<myNS::Date const ,myNS::myFunc *> > > > const >() Line 91 C++ myDLL.dll!myNS::myClass::serialize<boost::archive::binary_oarchive>() Line 68 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,myNS::myClass>(boost::archive::binary_oarchive & ar={...}, myNS::myClass & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,myNS::myClass>(boost::archive::binary_oarchive & ar={...}, myNS::myClass & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,myNS::myClass>(boost::archive::binary_oarchive & ar={...}, myNS::myClass & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::oserializer<boost::archive::binary_oar chive,myNS::myClass>::save_object_data(boost::archive::detail::basic_oar chive & ar={...}, const void * x=0x4d808780) Line 151 + 0x2b C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a1de() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa3e() myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,myNS::myClass>::save_standard::invoke(boost::archive::bi nary_oarchive & ar={...}, const myNS::myClass & t={...}) Line 263 + 0x15 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,myNS::myClass>::invoke(boost::archive::binary_oarchive & ar={...}, const myNS::myClass & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,myNS::myC lass>(boost::archive::binary_oarchive & ar={...}, const myNS::myClass & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<myNS::myClass const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<myNS::myClass const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<myNS::myClass const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<myNS::myClass const >() Line 80 C++ myDLL.dll!boost::serialization::nvp<myNS::myClass>::save<boost::archive: :binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<myNS::myClass> const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<myNS::myClass> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<myNS::myClass> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<myNS::myClass>::serialize<boost::arc hive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<myNS::myClass> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<myNS::myClass> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<myNS::myClass> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass> & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myClass> >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass> & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myClass> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass> & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<myNS::myClass> >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass> & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<myNS::myClass> const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<myNS::myClass> const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<myNS::myClass> const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<myNS::myClass> const >() Line 80 C++ myDLL.dll!boost::archive::detail::pointer_oserializer<myNS::myClass,boos t::archive::binary_oarchive>::save_object_ptr(boost::archive::detail::ba sic_oarchive & ar={...}, const void * x=0x4d808780) Line 216 C++ boost_serialization-vc71-mt-gd-1_34_1.dll!47f3a868() boost_serialization-vc71-mt-gd-1_34_1.dll!47f3aa6e() myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myClass const *>::polymorphic<myNS::myClass>::save(boost::archive::binary_oarchive & ar={...}, const myNS::myClass & t={...}, const boost::archive::detail::basic_pointer_oserializer * bpos_ptr=0x48eaf3c0) Line 401 + 0x13 C++ myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myClass const *>::save<myNS::myClass>(boost::archive::binary_oarchive & ar={...}, const myNS::myClass & t={...}, const boost::archive::detail::basic_pointer_oserializer * bpos_ptr=0x48eaf3c0) Line 438 + 0x11 C++ myDLL.dll!boost::archive::detail::save_pointer_type<boost::archive::bina ry_oarchive,myNS::myClass const *>::invoke(boost::archive::binary_oarchive & ar={...}, const myNS::myClass * const t=0x4d808780) Line 466 + 0x11 C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,myNS::myC lass const *>(boost::archive::binary_oarchive & ar={...}, const myNS::myClass * const & t=0x4d808780) Line 535 + 0xf C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<myNS::myClass const * const>() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<myNS::myClass const * const>() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<myNS::myClass const * const>() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<myNS::myClass const * const>() Line 80 C++ myDLL.dll!boost::serialization::nvp<myNS::myClass const *>::save<boost::archive::binary_oarchive>() Line 78 C++ myDLL.dll!boost::serialization::access::member_save<boost::archive::bina ry_oarchive,boost::serialization::nvp<myNS::myClass const *> const >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 94 C++ myDLL.dll!boost::serialization::detail::member_saver<boost::archive::bin ary_oarchive,boost::serialization::nvp<myNS::myClass const *> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 43 + 0x11 C++ myDLL.dll!boost::serialization::split_member<boost::archive::binary_oarc hive,boost::serialization::nvp<myNS::myClass const *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 69 + 0x11 C++ myDLL.dll!boost::serialization::nvp<myNS::myClass const *>::serialize<boost::archive::binary_oarchive>() Line 87 + 0x34 C++ myDLL.dll!boost::serialization::access::serialize<boost::archive::binary _oarchive,boost::serialization::nvp<myNS::myClass const *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 110 C++ myDLL.dll!boost::serialization::serialize<boost::archive::binary_oarchiv e,boost::serialization::nvp<myNS::myClass const *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 81 + 0x11 C++ myDLL.dll!boost::serialization::serialize_adl<boost::archive::binary_oar chive,boost::serialization::nvp<myNS::myClass const *> >(boost::archive::binary_oarchive & ar={...}, boost::serialization::nvp<myNS::myClass const *> & t={...}, const unsigned int file_version=0) Line 140 + 0x18 C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myClass const *> >::save_only::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass const *> & t={...}) Line 256 + 0xf C++ myDLL.dll!boost::archive::detail::save_non_pointer_type<boost::archive:: binary_oarchive,boost::serialization::nvp<myNS::myClass const *> >::invoke(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass const *> & t={...}) Line 321 + 0xd C++ myDLL.dll!boost::archive::save<boost::archive::binary_oarchive,boost::se rialization::nvp<myNS::myClass const *> >(boost::archive::binary_oarchive & ar={...}, const boost::serialization::nvp<myNS::myClass const *> & t={...}) Line 535 + 0xd C++ myDLL.dll!boost::archive::detail::common_oarchive<boost::archive::binary _oarchive>::save_override<boost::serialization::nvp<myNS::myClass const *> const >() Line 62 + 0x15 C++ myDLL.dll!boost::archive::basic_binary_oarchive<boost::archive::binary_o archive>::save_override<boost::serialization::nvp<myNS::myClass const *> const >() Line 66 C++ myDLL.dll!boost::archive::binary_oarchive_impl<boost::archive::binary_oa rchive,char,std::char_traits<char> >::save_override<boost::serialization::nvp<myNS::myClass const *> const >() Line 46 C++ myDLL.dll!boost::archive::detail::interface_oarchive<boost::archive::bin ary_oarchive>::operator<<<boost::serialization::nvp<myNS::myClass const *> const >(const boost::serialization::nvp<myNS::myClass const *> & t={...}) Line 80 C++ -- This e-mail is confidential and the information contained in it may be privileged. It should not be read, copied or used by anyone other than the intended recipient. If you have received it in error, please contact the sender immediately by telephoning +44 (0)20 7623 8000 or by return email, and delete the e-mail and do not disclose its contents to any person. We believe, but do not warrant, that this e-mail and any attachments are virus free, but you must take full responsibility for virus checking. Please refer to http://www.dresdnerkleinwort.com/disc/email/ and read our e-mail disclaimer statement and monitoring policy. Dresdner Kleinwort is the trading name of the investment banking division of Dresdner Bank AG, and operates through Dresdner Bank AG, Dresdner Kleinwort Limited, Dresdner Kleinwort Securities Limited and their affiliated or associated companies. Dresdner Bank AG is a company incorporated in Germany with limited liability and registered in England (registered no. FC007638, place of business 30 Gresham Street, London EC2V 7PG), and is authorised by the German Federal Financial Supervisory Authority and by the Financial Services Authority ('FSA') and regulated by the FSA for the conduct of designated business in the UK. Dresdner Kleinwort Limited is a company incorporated in England (registered no. 551334, registered office 30 Gresham Street, London EC2V 7PG), and is authorised and regulated by the FSA. Dresdner Kleinwort Securities Limited is a company incorporated in England (registered no. 1767419, registered office 30 Gresham Street, London EC2V 7PG), and is authorised and regulated by the FSA.

3 4

Re: [Boost-users] Serialization newbie needs help
by Dominick Layfield 22 Aug '07

22 Aug '07

Frank Birbacher wrote: > Robert Ramey schrieb: >> > The real easy way is just to use a binary_object which saves/loads a >> > specified number of bytes. >> > so the above would look like: >> > >> > void write_to_cbuffer(char* buf_p, size_t* buf_sz_p) { // note only one * >> > std::ostringstream oss; >> > boost::archive::text_oarchive oa(oss); >> > oa << binary_object(bf_sz_p, mc); >> > } >> > void read_from_cbuffer(const char* buf, const size_t buf_sz) { >> > std::istringstream iss(buf_str); >> > boost::archive::text_iarchive ia(iss); >> > ia >> binary_object(buf_sz, buf) >> > } > > You got this one mixed up. The char array is not something to serailize > but it is the storage to searialize to. The "read_from_cbuffer" function > does *read* the cbuffer and construct a my_class instance out of it by > using serialization. The "write_to_cbuffer" serializes a my_class > instance an stores the result in the cbuffer. > > I can think of using the old strstream class to read from the buffer or > take something from Boost.IOStreams. And writing could be faster if you > use a std::deque wrapped with IOStreams and later on std::copy this into > a char array (instead of memcpy). A deque has usually better performance > on push_back than a vector or string, I guess. But then I don't know the > internals of a stringstream. > > Frank Frank is right. I don't quite know what Robert thought I was looking for, but it's pretty clear that his suggested code does not do what I want. (Nor does it compile!) To clarify: write_to_cbuffer() should serialize a my_class instance into a c-style char* buffer. It also needs to dynamically allocate storage for the buffer, set buf_p to point at the buffer, and set buf_sz to the size of the buffer. This is so that the legacy C code can then call write(fd, buf_p, buf_sz). read_from_cbuffer() does the opposite: it extracts a serialized instance of my_class from a char* buffer. I'll take a look at the boost::iostreams stuff to see if I can figure out how to make that work. Thanks for the tip, Frank. BTW, I don't think a push_back() is any faster for a deque than a vector -- it is push_front() that is faster for a deque. From the STL docs at SGI: "The main way in which deque differs from vector is that deque also supports constant time insertion and removal of elements at the beginning of the sequence". -- Dominick

2 1

building Boost on MacOS: maybe I'm just too stupid but...
by Ole Christian Weidner 22 Aug '07

22 Aug '07

Aloha, I just tried to build Boost 1.34.1 fat (a.k.a. Universal) libraries for MacOS X. This is what happened: I created the following ~/user-config.jam file in order to build Universal libs: using darwin : # version : # command not specified ? use default : # options <compileflags>"-O -g -isysroot /Developer/SDKs/MacOSX10.4u.sdk - arch i386 -arch ppc" <linkflags>"-arch i386 -arch ppc" ; As described in http://www.boost.org/more/getting_started/unix- variants.html 5.1 "Easy Build and Install" I tried to fire up the build system like this: macpro01:/Volumes/Macintosh HD 2/boost_1_34_1 $ ./configure --prefix=/ usr/local/ Building Boost.Jam with toolset darwin... ./configure: line 198: cd: / Volumes/Macintosh: No such file or directory ./configure: line 1: cd: ./tools/jam/src: No such file or directory tools/jam/src//bjam Detecting Python version... 2.5 Detecting Python root... /sw Unicode/ICU support for Boost.Regex?... not found. Backing up existing Boost.Build configuration in user-config.jam.2 Generating Boost.Build configuration in user-config.jam... Generating Makefile... It seems that configure has a problem with "Macintosh HD 2" as a directory name... $ make make: *** No targets specified and no makefile found. Stop. WHATEVER - there's still the 5.2 "custom" way to build the boost libs: $ cd ~/boost_1_34_1/tools/jam/src $ ./build.sh $ cp bin.macosxx86/bjam ../../../ $ cd ~/boost_1_34_1/ $ ./bjam --prefix=/usr/local $ sudo ./bjam install ... 1 hour later everything _seems_ to be fine: $ file /usr/local/lib/libboost_filesystem-1_34_1.dylib /usr/local/lib/libboost_filesystem-1_34_1.dylib: Mach-O universal binary with 2 architectures /usr/local/lib/libboost_filesystem-1_34_1.dylib (for architecture i386): Mach-O dynamically linked shared library i386 /usr/local/lib/libboost_filesystem-1_34_1.dylib (for architecture ppc): Mach-O dynamically linked shared library ppc That's exactly what I wanted. But... THIS is really strange (test.cpp is the regex example from the install manual): $ g++ test.cpp -I/usr/local/include/boost-1_34_1/ -L/usr/local/lib/ - lboost_regex-mt-d-1_34_1 $ ./a.out dyld: Library not loaded: /var/tmp//ccMlDtbZ.out Referenced from: /Volumes/Macintosh HD 2/./a.out Reason: image not found Trace/BPT trap WHAT? I _never_ referenced a library called /var/tmp//ccMlDtbZ.out. What's going on here? Any help is GREATLY appreciated! Thanks, Ole

1 0

CLI: A boost command line interpreter based on boost Program Option
by JD 22 Aug '07

22 Aug '07

Hi all, I wrote a little command line interpreter based on the program option library by Vladimir Prus. You can find it here: http://minilien.com/?bNPy1ECuWv. It's not a big thing but can help sometime. You also have the subversion repository there: http://code.google.com/p/clipo/ Let me know what you think. JD

3 5

Re: [Boost-users] serialization lib, demo_shared_ptr.cpp, XML archives
by Robbie Morrison 22 Aug '07

22 Aug '07

Hello again After posting my earlier message <mailman.2403.1187719362.16337.boost-users(a)lists.boost.org>, I thought some more about 'demo_shared_ptr.cpp' and tried new fixes (isn't that always the way). My modified file 'demo_shared_ptr.mod.cpp' now builds and runs cleanly in both text and XML archive modes. The revised file is appended here. It contains some documentation at the end which may be worth reading. Note too that the data members named 'x' are now member initialized and this duly silences (Linux system) g++ compilier warnings and a raft of valgrind (memory checker) errors. I would now hope that a modified form of 'demo_shared_ptr.cpp' drawing on my experiences can be checked into the Boost SVN repository. I don't think I should be the person who does this, as I may have introduced subtle bugs or bad practice. Neither I have filed a bug report but would do so if asked. Finally, the presence of a buggy 'demo_shared_ptr.cpp' in both 1.33.1 and 1.34.1 almost caused me to give up on using Boost.Serialization. By all accounts, I am not the first to struggle with this demo file and fixing it should be accorded some priority. Many thanks, as always, to the developers and maintainers of Boost.Serialization! best regards to all Robbie --- Robbie Morrison PhD student -- policy-oriented energy system simulation Institute for Energy Engineering (IET) Technical University of Berlin (TU-Berlin), Germany [from IMAP client] // demo_shared_ptr.cpp : shows polymorphic pointer XML serialization // ******************************************************************* // MODIFICATION WARNING: this file has been modified by a Boost user // and is not part of the official Boost distribution. // ******************************************************************* // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . Polymorphic // derived pointer example by David Tonge. XML variant and some bug // fixes added by Robbie Morrison <robbie(a)actrix.co.nz> on 22-Aug-2007. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org for updates, documentation, and revision history. // // This file has been tested with Boost release 1.34.1 dated // 24-Jul-2007 (source build) and release 1.33.1 (Ubuntu package) // using the GNU GCC 4.1.2 compiler (with -Wall -pedantic), valgrind // version "valgrind-3.2.0-Debian" memory checker, and Linux Ubuntu // 6.10 operating system (now superseded by 7.04). The file builds // and runs cleanly under the conditions just listed. // // Unlike the 1.34.1 version of this demo, the archive file is not // deleted and can be subsequently examined using any pager utility or // text editor. // // Jump to the end of this file for a discussion on some of the coding // practices employed. // --------------------------------------------------------- // Preprocessor directives controlling archive type // --------------------------------------------------------- // these can be reset lower values to aid troubleshooting // 0 = straight text, 1 = text with NVP (name-value-pair) statements, 2 = xml #define ARCHIVE_MODE 2 // 0 = omit David Tonge derived pointer code, 1 = use derived pointer code #define POLYMORPHIC_CODE 1 // --------------------------------------------------------- #include <iomanip> // setw() and family #include <iostream> // standard io #include <fstream> // file-based io #include <string> // C++ strings #include <boost/archive/tmpdir.hpp> // locate a temporary directory #if (ARCHIVE_MODE >= 2) # include <boost/archive/xml_iarchive.hpp> // archive for loading XML # include <boost/archive/xml_oarchive.hpp> // archive for saving XML #else # include <boost/archive/text_iarchive.hpp> // archive for loading text # include <boost/archive/text_oarchive.hpp> // archive for saving text #endif #include <boost/serialization/shared_ptr.hpp> // shared_ptr serialization #include <boost/serialization/base_object.hpp> // base class serialization #include <boost/serialization/export.hpp> // explicit code for exports (place last) class A { friend class boost::serialization::access; private: template <class Archive> void serialize (Archive& ar, const unsigned int class_version) { #if (ARCHIVE_MODE >= 1) ar & BOOST_SERIALIZATION_NVP(x); // boost::serialization::make_nvp("x", x) #else ar & x; // simple form for text archives #endif } int x; public: A(): x(42) { ++count; } // default constructor, the 42 is arbitrary virtual ~A() { --count; } static int count; // public in order to simplify test code }; BOOST_CLASS_EXPORT(A) // requires <boost/serialization/export.hpp> // if using particular Metrowerks or Borland compilers, uncomment the following: // BOOST_SERIALIZATION_SHARED_PTR(B) int A::count = 0; class B : public A // class B added by David Tonge { friend class boost::serialization::access; private: int x; template<class Archive> void serialize(Archive& ar, const unsigned int class_version) { #if (ARCHIVE_MODE >= 1) //ar & boost::serialization::base_object<A>(*this); // CAUTION: problematic for XML ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); // .. but this works fine ar & BOOST_SERIALIZATION_NVP(x); #else ar & boost::serialization::base_object<A>(*this); // this is fine for text //ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); // .. and this also works ar & x; // x now saved (unlike 1.34.1) #endif } public: B() : A(), x(84) { ++count; } // default constructor, the 84 is arbitrary virtual ~B() { --count; } static int count; }; // if using particular Metrowerks or Borland compilers, uncomment the following: // BOOST_SERIALIZATION_SHARED_PTR(B) BOOST_CLASS_EXPORT(B) int B::count = 0; void display(boost::shared_ptr<A>& a, boost::shared_ptr<A>& a1) { std::cout << "a = 0x" << std::hex << a.get() << std::dec << ", "; if (a.get()) std::cout << "is a " << typeid(*(a.get())).name() << "*, "; std::cout << "use count = " << std::dec << a.use_count() << std::endl; std::cout << "a1 = 0x" << std::hex << a1.get() << std::dec << ", "; if (a1.get()) std::cout << "is a " << typeid(*(a1.get())).name() << "*, "; std::cout << "use count = " << std::dec << a1.use_count() << std::endl; std::cout << "unique element count = " << A::count << std::endl; std::cout << std::endl; } int main(int argc, char* argv[]) { // report some build details to the console std::cout << std::endl; std::cout << "archive mode : " << ARCHIVE_MODE << std::endl; std::cout << "DT extension mode : " << POLYMORPHIC_CODE << std::endl; // name the archive file appropriately #if (ARCHIVE_MODE >= 2) std::string ext = "xml"; // XML archive #else std::string ext = "txt"; // text archive #endif std::string filename(boost::archive::tmpdir()); //locate a temporary directory filename += "/demo_shared_ptr"; filename += "."; filename += ext; std::cout << "testfile name : " << filename << std::endl; std::cout << std::endl; // note the test type std::cout << "base smart pointer tests" << std::endl; std::cout << std::endl; // create a new shared pointer to a new object of type A boost::shared_ptr<A> spa(new A()); boost::shared_ptr<A> spa1; spa1 = spa; display(spa, spa1); // serialize the pointers { // open the archive file std::ofstream ofs(filename.c_str()); #if (ARCHIVE_MODE >= 2) boost::archive::xml_oarchive oa(ofs); #else boost::archive::text_oarchive oa(ofs); #endif #if (ARCHIVE_MODE >= 1) oa << BOOST_SERIALIZATION_NVP(spa); oa << BOOST_SERIALIZATION_NVP(spa1); #else oa << spa; oa << spa1; #endif } // reset the shared pointer to NULL thereby destroying the type A object spa.reset(); spa1.reset(); display(spa, spa1); // restore state to one equivalent to the original { // open the archive file std::ifstream ifs(filename.c_str()); #if (ARCHIVE_MODE >= 2) boost::archive::xml_iarchive ia(ifs); #else boost::archive::text_iarchive ia(ifs); #endif #if (ARCHIVE_MODE >= 1) ia >> BOOST_SERIALIZATION_NVP(spa); ia >> BOOST_SERIALIZATION_NVP(spa1); #else ia >> spa; ia >> spa1; #endif } display(spa, spa1); spa.reset(); spa1.reset(); #if (POLYMORPHIC_CODE >= 1) // that is, use derived pointer code // note the test type std::cout << "derived smart pointer tests" << std::endl; std::cout << std::endl; // new code by David Tonge starts here // create a new shared pointer to a new object of type A spa = boost::shared_ptr<A>(new B()); spa1 = spa; display(spa, spa1); // serialize it // CAUTION: archive saved earlier will be simply overwritten { std::ofstream ofs(filename.c_str()); #if (ARCHIVE_MODE >= 2) boost::archive::xml_oarchive oa(ofs); #else boost::archive::text_oarchive oa(ofs); #endif #if (ARCHIVE_MODE >= 1) oa << BOOST_SERIALIZATION_NVP(spa); oa << BOOST_SERIALIZATION_NVP(spa1); #else oa << spa; oa << spa1; #endif } // reset the shared pointer to NULL thereby destroying the type B object spa.reset(); spa1.reset(); display(spa, spa1); // restore state to one equivalent to the original { // reopen the archive std::ifstream ifs(filename.c_str()); #if (ARCHIVE_MODE >= 2) boost::archive::xml_iarchive ia(ifs); #else boost::archive::text_iarchive ia(ifs); #endif #if (ARCHIVE_MODE >= 1) ia >> BOOST_SERIALIZATION_NVP(spa); ia >> BOOST_SERIALIZATION_NVP(spa1); #else ia >> spa; ia >> spa1; #endif } display(spa, spa1); #endif // POLYMORPHIC_CODE return 0; } // main() // --------------------------------- // Output // --------------------------------- // // archive mode : 2 // DT extension mode : 1 // testfile name : ./demo_shared_ptr.xml // // base smart pointer tests // // a = 0x0x42ca428, is a 1A*, use count = 2 // a1 = 0x0x42ca428, is a 1A*, use count = 2 // unique element count = 1 // // a = 0x0, use count = 0 // a1 = 0x0, use count = 0 // unique element count = 0 // // a = 0x0x42d3a08, is a 1A*, use count = 2 // a1 = 0x0x42d3a08, is a 1A*, use count = 2 // unique element count = 1 // // derived smart pointer tests // // a = 0x0x42d4ab0, is a 1B*, use count = 2 // a1 = 0x0x42d4ab0, is a 1B*, use count = 2 // unique element count = 1 // // a = 0x0, use count = 0 // a1 = 0x0, use count = 0 // unique element count = 0 // // a = 0x0x42de180, is a 1B*, use count = 2 // a1 = 0x0x42de180, is a 1B*, use count = 2 // unique element count = 1 // --------------------------------- // Coding practices // --------------------------------- // // Polymorphic behavior // // This demo does involve polymorphic behavior due to the // presence of a virtual function in the base class, in this case // the virtual destructor for A: // // virtual ~A(); // gives rise to polymorphic behavior // // If you wish to experiment, remove the virtual specifier and // note the now much reduced XML archive. // // Default (zero-argument) constructor // // All deserialized classes need a default constructor. This // need not be explicitly defined, in which case the // compiler-supplied version is used. For deserialization // purposes, the default constructor can be private (although // other design considerations will normally mean that it is, at // most, protected). // // Class registration // // In this demo, class registration relies on explicit export of // the class and its globally unique identifier (GUID). This is // achieved using the following macro: // // BOOST_CLASS_EXPORT(Class) // "Class" becomes the GUID // // This form of class registration is known as "key export". A // more general macro also exists (but was not employed here) in // which the client code actively manages the GUID: // // BOOST_CLASS_EXPORT_GUID(Class, "my-guid") // // Class registration can also be accomplished by inserting a C++ // registration statement within 'serialize' or, in some cases, // placing reliance on serialization order. However these other // approaches require an up-front knowledge of the class // hierarchy or are dependent on program flow. Key export is // hence the more flexible and less brittle strategy and should // therefore be preferred. Moreover, it is probably good // practice to explicitly export all serialized classes, even when // this is not strictly required. // // Base/derived information // // Class hierarchy information is communicated here using the // following macro: // // ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseClass); // // As before, a direct C++ statement is possible. However this // broke for the XML format archive (I didn't investigate why). // Hence it would appear that use of the above macro is necessary // when serializing to XML. // // Non-default names/GUIDs // // If a macro which employs an explicit object name or class GUID // is used, then the new string literal must be valid XML. In // particular, whitespace is not acceptable and its use will // generate an "unrecognized XML syntax" exception at run-time: // // using boost::serialization::make_nvp; // ar & make_nvp("my data", data); // run-time exception // // Associated headers // // Read the code itself for more information on the associated // headers and their correct placement: // // <boost/serialization/base_object.hpp> // <boost/serialization/export.hpp> // // Build and run command-lines (your library name may be different) // // all warnings (the grep screening relates to -Weffc++, see man g++): // // $ g++ -ggdb -Wall -Weffc++ -pedantic // demo_shared_ptr.mod.cpp // -lboost_serialization-gcc41 // -o demo_shared_ptr // 2>&1 // | grep --invert-match '/usr/local/include/boost-1_34_1/boost' // | grep --invert-match 'instantiated from' // // simplified build: // // $ g++ demo_shared_ptr.mod.cpp // -lboost_serialization-gcc41 // -o demo_shared_ptr // // run with memory checking: // // $ valgrind ./demo_shared_ptr // // simplified run: // // $ ./demo_shared_ptr // // Compile-time static asserts // // These may be difficult to interpret (in my limited // experience). Note that a pointer to a C++ fundamental type // (for example, int*) cannot be de/serialized. // // Run-time exceptions // // Some common messages and probable fixes (based on the style // recommendations above): // // "unregistered_class" // missing: BOOST_CLASS_EXPORT(SubClass) // // "unregistered void cast" // missing: ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseClass); // // "unrecognized XML syntax" // name-value-pair name contains whitespace // end of file demo_shared_ptr.mod.cpp

2 1

Re: [Boost-users] [Boost][Serialization] Possible Bug inOptional.hpp
by Marc Viala 22 Aug '07

22 Aug '07

Thanks for your quick answer Robert. Sure it doesn't affect the program behaviour but the debug with Visual C++ IDE is little bit more painful ;-). I'm going to fix my own copy of the file. Marc Viala De la part de Robert Ramey clearly its a bug but it shouldn't affect any programs, I'll fix it in my working copy. You can fix it by just initializing to 0. Robert Ramey "Marc Viala" <mviala(a)acticm.com> wrote in message news:D0D608FD34E14C4BA93A30AC162651E18BA519@SERVEUR2003.acticm.com... I've downloaded recently the version Boost 1.34.1 and performed some tests on ours applications integrating Boost components. During theses tests, I've tried to deserialize some XML archives generated w/ Boost 1.33.1 including some boost::optional<> instances and I've observed that the Visual C++ 7.1 IDE emits run-time checks in the load<boost::optional<>>() @ line 60 in file boost/serialization/optional.hpp. template<class Archive, class T> void load( Archive & ar, boost::optional<T> & t, const unsigned int /*version*/ ){ bool tflag; ar >> boost::serialization::make_nvp("initialized", tflag); if (tflag){ unsigned int v; if(3 < ar.get_library_version()){ ar >> make_nvp("item_version", v); } detail::stack_construct<Archive, T> aux(ar, v); ^^^^^^^^^^^^^^^^^^^^^^^^ Here Run-Time Check Failure #3 - The variable 'v' is being used without being defined. ar >> boost::serialization::make_nvp("value", aux.reference()); t.reset(aux.reference()); } else { t.reset(); } } Is it possible to avoid this run-time check by a preinitialisation of the local variable "v"? Is it a Bug? Best regards, Used Configurations: Windows XP Boost 1.34.1 (through Boost Installer w/ DLL libraries) Marc Viala

1 0

regex_search all
by izua 22 Aug '07

22 Aug '07

How can I do a regex search that will return me all patterns for the given regular expression? Somehow like preg_match_all in PHP. -- View this message in context: http://www.nabble.com/regex_search-all-tf4292590.html#a12219928 Sent from the Boost - Users mailing list archive at Nabble.com.

3 6

Re: [Boost-users] [statechart] using events for passing information
by "Christian Bähnisch" 22 Aug '07

22 Aug '07

I'm working on a controller connected to a external device through a serial port. I have to process events triggered by the device which can be group into several categories like simple status events "My firmware has version XXXX" or "the result of my last working step was XXXX" as you can see my events carry data. I want to encapsulate this communication events in statechart events, so I can change to states depending on the event's category, and then make further processing where I have to extract data I have passed into them. I thought this would be a common use case for a statechart appproach ... -- GMX FreeMail: 1 GB Postfach, 5 E-Mail-Adressen, 10 Free SMS. Alle Infos und kostenlose Anmeldung: http://www.gmx.net/de/go/freemail

2 1

[Boost][Serialization] Possible Bug in Optional.hpp
by Marc Viala 22 Aug '07

22 Aug '07

I've downloaded recently the version Boost 1.34.1 and performed some tests on ours applications integrating Boost components. During theses tests, I've tried to deserialize some XML archives generated w/ Boost 1.33.1 including some boost::optional<> instances and I've observed that the Visual C++ 7.1 IDE emits run-time checks in the load<boost::optional<>>() @ line 60 in file boost/serialization/optional.hpp. template<class Archive, class T> void load( Archive & ar, boost::optional<T> & t, const unsigned int /*version*/ ){ bool tflag; ar >> boost::serialization::make_nvp("initialized", tflag); if (tflag){ unsigned int v; if(3 < ar.get_library_version()){ ar >> make_nvp("item_version", v); } detail::stack_construct<Archive, T> aux(ar, v); ^^^^^^^^^^^^^^^^^^^^^^^^ Here Run-Time Check Failure #3 - The variable 'v' is being used without being defined. ar >> boost::serialization::make_nvp("value", aux.reference()); t.reset(aux.reference()); } else { t.reset(); } } Is it possible to avoid this run-time check by a preinitialisation of the local variable "v"? Is it a Bug? Best regards, Used Configurations: Windows XP Boost 1.34.1 (through Boost Installer w/ DLL libraries) Marc Viala

2 1

Re: [Boost-users] Serialization newbie needs help
by Dominick Layfield 22 Aug '07

22 Aug '07

>> > Obviously, I can just switch to a different serialization library >> > (e.g. s11n). > > I believe that library also has serialization of pointers Darn it! Foiled at every turn! :-) If that is the case, maybe you might consider updating/clarifying the "Overview -> Other implementations" section of the docs. There you imply that s11n doesn't do this. (Maybe it didn't back when you wrote the docs.) >> But as much as possible, I would like to stick with >> > whatever is most "standard". And as part of the Boost family, I'm >> > guessing that boost::serialization is top dog here. Would that be >> > right? Is this library included in any of the proposed C++ >> > standards (TR2, C++0x)? > > This serialization library will never be part of any C++ standard. Oh. That's disappointing. Why not? Too much bureaucracy involved? > Because normally one doesn't want to change data while its being saved > one will typically have something like the following in his program. > > FileSave(const MyData & md){ > // create archive > oa << md; // no need for "const cast" because md is already "const" > ... > } Okay. That makes a lot of sense. Let me ask another newbie question, about how to get data in and out of an archive. I have to work with legacy C-based code that delivers/accepts data in a char* buffer. My code to serialize data into and out of this buffer is both convoluted and inefficient. It looks something like this: my_class mc; void read_from_cbuffer(const char* buf, const size_t buf_sz) { std::string buf_str(buf, buf_sz); std::istringstream iss(buf_str); boost::archive::text_iarchive ia(iss); ia >> mc; } void write_to_cbuffer(char** buf_p, size_t* buf_sz_p) { std::ostringstream oss; boost::archive::text_oarchive oa(oss); oa << mc; *buf_p = new char[oss.str().size()]; memcpy(*buf_p, oss.str().c_str(), oss.str().size()); *buf_sz_p = oss.str().size(); } Any suggestions about how this can be done better? Thanks, -- Dominick

4 3

Boost 1.34.1 + MinGW + STLport5-dll
by Johannes Barop 22 Aug '07

22 Aug '07

Hello, I'm trying to build Boost 1.34.1 with MinGW and STLport5. With no success. I created a user-config.jam in my home directory with following content: <snip> using stlport : 5.1 : "C:\\MinGW\\STLport-5.1.3\\stlport" "C:\\MinGW\\STLport-5.1.3\\lib" ; </snip> Then I tryed to build Boost with the following command line: bjam --toolset=gcc stage stdlib=stlport runtime-link=shared Which gave me a lots of errors. See here: http://nopaste.php-quake.net/2727 Any ideas what might be wrong? Cheers, Johannes

1 0

Subject : [Multi-index] -- using a hashed unique index that is not part of the hashed value
by Oliver Kania 22 Aug '07

22 Aug '07

Hello, what I basically want to do is using multi-index like a hashmap. I want to use vector<long> as key. However, all the examples I found are using member-fields of the values or the values themselves as key. Is it not possible to use multi-index like a hash_map<value,key> where the key is independent of the value type ? If yes, could someone please provide an example ? regards, Oliver

2 2

Re: [Boost-users] boost bind beginner throw problem
by Taglioretti Roberto 22 Aug '07

22 Aug '07

From: "Peter Dimov" > The following program works for me with VC 7.1. > #include <boost/bind.hpp> > struct Error {}; > struct X { void test( int i ) throw( Error ) {}}; > int main() > { > X obj; > boost::bind( &X::test, obj, _1 ); >} I try to compile your example, theese are the error messages on my VC 7.1: C:\sviluppo\r2\boost\build\1.34.1\include\boost\lambda\detail\bind_functions.hpp(544): error C2553: no legal conversion of return value to return type 'type' "const boost::lambda::lambda_functor<T>" with [ T=boost::lambda::lambda_functor_base<boost::lambda::action<4,boost::lambda::function_action<4>>,boost::tuples::tuple<const boost::lambda::detail::bind_traits<void (__thiscall SVLCompiler::Analysis::* const )(SVLCompiler::Analysis::Iteratorp_t,SVLCompiler::Analysis::Iteratorp_t)>::type,const boost::lambda::detail::bind_traits<SVLCompiler::Analysis *const >::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder1_type>::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder2_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type>> ] C:\sviluppo\r2\boost\build\1.34.1\include\boost\lambda\detail\bind_functions.hpp(544): error C2664: "boost::lambda::lambda_functor<T>::lambda_functor(const boost::lambda::lambda_functor<T> &)": impossibile convertire il parametro 1 da "boost::lambda::lambda_functor_base<Act,Args>" a "const boost::lambda::lambda_functor<T> &" with [ T=boost::lambda::lambda_functor_base<boost::lambda::action<4,boost::lambda::function_action<4>>,boost::tuples::tuple<const boost::lambda::detail::bind_traits<void (__thiscall SVLCompiler::Analysis::* const )(SVLCompiler::Analysis::Iteratorp_t,SVLCompiler::Analysis::Iteratorp_t)>::type,const boost::lambda::detail::bind_traits<SVLCompiler::Analysis *const >::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder1_type>::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder2_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type>> ] and [ Act=boost::lambda::action<4,boost::lambda::function_action<4>>, Args=boost::tuples::tuple<const boost::lambda::detail::bind_traits<void (__thiscall SVLCompiler::Analysis::* const )(SVLCompiler::Analysis::Iteratorp_t,SVLCompiler::Analysis::Iteratorp_t) throw(SVLCompiler::Analysis::Error_check)>::type,const boost::lambda::detail::bind_traits<SVLCompiler::Analysis *const >::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder1_type>::type,const boost::lambda::detail::bind_traits<const boost::lambda::placeholder2_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type, I hope you can help me :-( -- Roberto Taglioretti *sono affetto da discromatopsia, per favore evitate l'invio di mail o allegati colorati* *I have dyschromatopsia, please do not send coloured text or email and attach* Aderite al progetto SETI: http://setiweb.ssl.berkeley.edu/team_display.php?teamid=30233

2 1

boost::spirit
by Christer Borgqvist 22 Aug '07

22 Aug '07

Hello Boost Experts I'm using the BDS 2006 and trying to use the spirit library like this #include <boost/spirit.hpp> in my function string hex="0x1F"; unsigned int value; parse( hex.c_str() , hex_p[assign_a(value)] ); // i get following compiler error [C++ Error] closures.hpp(238): E2299 Cannot generate template specialization from 'impl::closure_frame_holder<FrameT>' thanks for any help //Christer

3 2

Bug in shared_array
by Hansi Hansi 22 Aug '07

22 Aug '07

Hello, I think I have found an bug in the shared_array implementation in version 1.34.1 for VC8.0. I hope that this is the right location to post this and that one fixes this file. I think that the implementation needs this: #elif defined( _MANAGED ) static void unspecified_bool( this_type*** ) { } typedef void (*unspecified_bool_type)( this_type*** ); operator unspecified_bool_type() const // never throws { return px == 0? 0: unspecified_bool; } it is the same implementation as used in shared_ptr. If I don't have this I get during the call a buffer overrun. Best regards Hansjörg __________________________________________________________________________ Erweitern Sie FreeMail zu einem noch leistungsstärkeren E-Mail-Postfach! Mehr Infos unter http://produkte.web.de/club/?mc=021131

1 0

Re: [Boost-users] Serialization newbie needs help
by Dominick Layfield 21 Aug '07

21 Aug '07

"Robert Ramey" <ramey(a)rrsd.com> wrote: > Actually, I've considered reviewing all the email in this list and > summarizing > the results in a section "Hints and Troubleshooting Tips". I think this > is useful and necessary and useful, but I just havent gotten around to it. That sounds ideal. > > But if you could provide me an example of when pointer serialization > > shines, > > then I would say "Aha! Now I understand why Robert went to so much > > trouble to make this work.", and I could be at peace with the world > > again! :-) > > LOL - I haven't had time to make any real apps lately. So... no example at all? My problem is that I just don't see when pointer serialization would be a big win. But I can't tell if I just have a limited perspective. That's why I was genuinely hoping that you could provide a concrete example. Naturally, a system that "just works" no matter what structure is thrown at it sounds very enticing. However, as you have acknowledged, the system is not foolproof, and user gotchas remain. One way to eliminate the gotchas would be to reduce the scope of the library. Clearly, this is unlikely to happen, as (i) you've invested a lot of time and effort getting the pointer magic to work, and (ii) there are probably a lot of applications out there that would break if you did so. I for one would certainly appreciate a simplified version which omitted the pointer magic, and thus removed the const trap and similar issues. If I want to set up pointers within an object, then I can do so manually using the type-specific load()/save() functions. Obviously, I can just switch to a different serialization library (e.g. s11n). But as much as possible, I would like to stick with whatever is most "standard". And as part of the Boost family, I'm guessing that boost::serialization is top dog here. Would that be right? Is this library included in any of the proposed C++ standards (TR2, C++0x)? > > BTW, I don't want to sound like I'm bashing your library, so let me > > end with a compliment. I think the symmetric design of serialize(), > > with the same function used for both input and output, is one of the > > prettiest > > idioms I've seen in years. > > And that's the one thing I didn't do - I believe I "borrowed" it from Jens > Maurer. Hah! Ooops. Well, that compliment backfired! ;-) Let's try again: I *really* appreciate the built-in support for all the STL container classes. So far, these have "just worked" perfectly for me. Nice work! > One tiny point. I'm aware that the "const" trap is annoying. But I've > become > convinced that the annoyance is small compared to the hassles it saves me > and users from. I suspect that those who have a problem with aren't in the > habit of using "const" everywhere they can. It does seem bizarre to have to const-cast an object just so that it can be output. I presume that the majority of objects that are to be serialized are not intrinsically constant, so this needs to be done the majority of the time. And it looks dangerous. What does the const-cast actually mean in this context? I assume it means: "I promise that no other thread is going to modify the object (or anything its pointers point to) while the serialize() operation is pending. Is that correct? If so, then shouldn't it be solved explicitly with concurrent programming primitives (i.e. mutexes or similar)? -- Dominick

5 7

An easy one
by Panayiotis 21 Aug '07

21 Aug '07

Hello, what is the equivalent of: void foo(int array[]) for boost::array? Thanks, Panayiotis

4 6

Can Python "httplib" module be directly embedded in C++ ?
by Raja Cherukuri 21 Aug '07

21 Aug '07

Hello, I am trying to use python to do my XML post ? Can I do this by directly calling import on the httplib like this and setting parameters ? ex: boost::python::object http_module((boost::python::handle<>(boost::python::borrowed(PyImport_Ad dModule("httplib"))))); boost::python::<....some kind of python compile time...interface...> h = < some kind of cast...> http_module.HTTP("http://www.abc.com"); h.putrequest('POST', selector) h.putheader('content-type', content_type) h.putheader('content-length', str(len(body))) h.endheaders() h.send(body) Or should the actual code for this object reside in a text file and I should call exec_file ? Thanks in Advance. - Raja

2 6

[mpl] Is it possible to mpl_assert depending on the derivation of a class
by Hughes, James 21 Aug '07

21 Aug '07

Hello all, I want some template code to assert if the passed in template type is NOT derived from a particular base class. I've looked through the Template Metaprogamming book, but haven't seen anything that can do this, but I seem to remember something along those lines. Can anyone help? James This message (including any attachments) contains confidential and/or proprietary information intended only for the addressee. Any unauthorized disclosure, copying, distribution or reliance on the contents of this information is strictly prohibited and may constitute a violation of law. If you are not the intended recipient, please notify the sender immediately by responding to this e-mail, and delete the message from your system. If you have any questions about this e-mail please notify the sender immediately.

4 9

serialization lib, demo_shared_ptr.cpp, XML archives
by Robbie Morrison 21 Aug '07

21 Aug '07

Hello all My problem is similar to that discussed by Phil and Robert Ramey on 'Boost - Users' back in 08-Feb-2007. Their thread was titled "serialization stream error". Phil however did not post back a follow up and it remains unclear as to whether his difficulties were resolved or not. Moreover, these discussions predate the 1.34.1 release on 24-Jul-2007 by about five months. For my part, I have tried solving the problem covered in this email using: - Boost 1.33.1 from an Ubuntu package and dated 05-Dec-2005 - Boost 1.34.1 built from source under Ubuntu 6.10 I would like to get 'demo_shared_ptr.cpp' to run using XML rather than text as the archive format -- as a precursor to integrating this kind of code into an energy system simulation. I decided to use a step-by-step approach: step 1 - build and run the original 'demo_shared_ptr.cpp' using the original text archive format - therefore, remove the leading A:: and B:: from constructor and destructor definitions - comment out the following (two places): oa.register_type(static_cast<boost::detail::sp_counted_base_impl > *>(NULL)); [as far as I could tell 'sp_counted_base_impl' no longer exists] step 2 - add NVP statements while retaining the text archive format for the time being - therefore, swap over all archive calls, for instance: // ar & x; ar & boost::serialization::make_nvp("x", x); step 3 - switch to the XML archive format - duly change the following headers: // #include <boost/archive/text_iarchive.hpp> // #include <boost/archive/text_oarchive.hpp> #include <boost/archive/xml_iarchive.hpp> #include <boost/archive/xml_oarchive.hpp> - duly change the archive objects: // boost::archive::text_oarchive oa(ofs); boost::archive::xml_oarchive oa(ofs); Step 3 fails but only in the derived pointer code added by David Tonge to 'demo_shared_ptr.cpp'. A 'boost::STATIC_ASSERTION_FAILURE' is generated. Typical error messages are given after the main body of this posting. At this point, I ran out of ideas. I have read the HTML documentation and made my own notes and still can't see a solution. Any assistance would be very gratefully received! Note too that I only log on once per day so don't expect a rapid turn-around for requests for details. In addition, I will send diffs to the maintainer when I get a satisfactory solution. And, in passing, it is material to note that derived class B does not fully archive its state and that there should probably be an "ar & x" statement in its 'serialize' definition. For the record, here is my development environment: os : Ubuntu 6.10, Linux 2.6.17-12-generic hardware : Toshiba Tecra A2 330 laptop (purchased 27-Aug-2004) specs : 1.4GHz Intel Celeron M (32-bit) / 512MiB RAM / 40GB HDD / 1024x76 gcc : gcc (GCC) 4.1.2 20060928 (prerelease) (Ubuntu 4.1.1-13ubuntu5) I realize that this is not the latest release of Ubuntu, but otherwise my system is fully current. Lastly, I take it Boost.Serialization and TR1 shared pointers (std::tr1::shared_ptr) remain incompatible at this point in development. Many thanks to Robert Ramey for developing Boost.Serialization. It suits my needs to a tee, so I hope I can get this issue resolved and move on with real coding. best wishes Robbie --------------------------------- selected error messages --------------------------------- /usr/local/include/boost-1_34_1/boost/archive/basic_xml_oarchive.hpp: In member function 'void boost::archive::basic_xml_oarchive<Archive>::save_override(T&, int) [with T = const A, Archive = boost::archive::xml_oarchive]': /usr/local/include/boost-1_34_1/boost/archive/detail/interface_oarchive.hpp:79: instantiated from 'Archive& boost::archive::detail::interface_oarchive<Archive>::operator<<(T&) [with T = const A, Archive = boost::archive::xml_oarchive]' /usr/local/include/boost-1_34_1/boost/archive/detail/interface_oarchive.hpp:87: instantiated from 'Archive& boost::archive::detail::interface_oarchive<Archive>::operator&(T&) [with T = A, Archive = boost::archive::xml_oarchive]' qdemo_shared_ptr.mod01.cpp:76: instantiated from 'void B::serialize(Archive&, unsigned int) [with Archive = boost::archive::xml_oarchive]' /usr/local/include/boost-1_34_1/boost/serialization/access.hpp:109: instantiated from 'static void boost::serialization::access::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::xml_oarchive, T = B]' /usr/local/include/boost-1_34_1/boost/serialization/serialization.hpp:81: instantiated from 'void boost::serialization::serialize(Archive&, T&, unsigned int) [with Archive = boost::archive::xml_oarchive, T = B]' /usr/local/include/boost-1_34_1/boost/serialization/serialization.hpp:140: instantiated from 'void boost::serialization::serialize_adl(Archive&, T&, unsigned int) [with Archive = boost::archive::xml_oarchive, T = B]' /usr/local/include/boost-1_34_1/boost/archive/detail/oserializer.hpp:225: instantiated from 'boost::archive::detail::pointer_oserializer<T, Archive>::pointer_oserializer() [with T = B, Archive = boost::archive::xml_oarchive]' /usr/local/include/boost-1_34_1/boost/archive/detail/oserializer.hpp:197: instantiated from 'const boost::archive::detail::pointer_oserializer<B, boost::archive::xml_oarchive> boost::archive::detail::pointer_oserializer<B, boost::archive::xml_oarchive>::instance' /usr/local/include/boost-1_34_1/boost/archive/detail/oserializer.hpp:189: instantiated from 'static const boost::archive::detail::pointer_oserializer<T, Archive>& boost::archive::detail::pointer_oserializer<T, Archive>::instantiate() [with T = B, Archive = boost::archive::xml_oarchive]' /usr/local/include/boost-1_34_1/boost/archive/detail/oserializer.hpp:514: instantiated from 'const boost::archive::detail::basic_pointer_oserializer& boost::archive::detail::instantiate_pointer_oserializer(Archive*, T*) [with Archive = boost::archive::xml_oarchive, T = B]' /usr/local/include/boost-1_34_1/boost/archive/detail/interface_oarchive.hpp:59: instantiated from 'const boost::archive::detail::basic_pointer_oserializer* boost::archive::detail::interface_oarchive<Archive>::register_type(const T*) [with T = B, Archive = boost::archive::xml_oarchive]' demo_shared_ptr.mod01.cpp:200: instantiated from here /usr/local/include/boost-1_34_1/boost/archive/basic_xml_oarchive.hpp:83: error: invalid application of 'sizeof' to incomplete type 'boost::STATIC_ASSERTION_FAILURE<false>' --------------------------------- my modifications --------------------------------- $ diff -u demo_shared_ptr.cpp demo_shared_ptr.mod01.cpp --- demo_shared_ptr.cpp 2007-08-21 11:51:35.000000000 +0200 +++ demo_shared_ptr.mod01.cpp 2007-08-21 14:44:33.000000000 +0200 @@ -9,6 +9,21 @@ // // See http://www.boost.org for updates, documentation, and revision history. +// build : $ g++ -ggdb -Wall demo_shared_ptr.mod01.cpp +// -lboost_serialization-gcc41 -o demo_shared_ptr +// run : $ demo_shared_ptr + +// --------------------------------------------------------- +// PREPROCESSOR DIRECTIVES +// --------------------------------------------------------- + +// 0 = text, 1 = text with NPV statements, 2 = xml +#define XEONA_ARCHIVE_MODE 2 +// 0 = omit DT code, 1 = use DT code +#define DT_CODE 1 + +// --------------------------------------------------------- + #include <iomanip> #include <iostream> #include <fstream> @@ -17,15 +32,23 @@ #include <cstdio> // remove #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) -namespace std{ +namespace std{ using ::remove; } #endif -#include <boost/archive/text_oarchive.hpp> -#include <boost/archive/text_iarchive.hpp> +#if (XEONA_ARCHIVE_MODE >= 2) +# include <boost/archive/xml_oarchive.hpp> +# include <boost/archive/xml_iarchive.hpp> +#else +# include <boost/archive/text_oarchive.hpp> +# include <boost/archive/text_iarchive.hpp> +#endif + #include <boost/archive/tmpdir.hpp> +//#include <boost/serialization/base_object.hpp> // base class serialization + #include <boost/serialization/shared_ptr.hpp> /////////////////////////// @@ -37,12 +60,18 @@ int x; template<class Archive> void serialize(Archive & ar, const unsigned int /* file_version */){ - ar & x; + +#if (XEONA_ARCHIVE_MODE >= 1) + ar & boost::serialization::make_nvp("x", x); +#else + ar & x; +#endif + } public: static int count; - A::A(){++count;} // default constructor - virtual A::~A(){--count;} // default destructor + A(){++count;} // default constructor + virtual ~A(){--count;} // default destructor }; BOOST_SERIALIZATION_SHARED_PTR(A) @@ -56,12 +85,18 @@ int x; template<class Archive> void serialize(Archive & ar, const unsigned int /* file_version */){ - ar & boost::serialization::base_object<A>(*this); + +#if (XEONA_ARCHIVE_MODE >= 1) + ar & boost::serialization::base_object<A>(*this); // problem +#else + ar & boost::serialization::base_object<A>(*this); +#endif + } public: static int count; - B::B() : A() {}; - virtual B::~B() {}; + B() : A() {}; + virtual ~B() {}; }; BOOST_SERIALIZATION_SHARED_PTR(B) @@ -83,8 +118,30 @@ int main(int argc, char *argv[]) { + std::cout << std::endl; + std::cout << "xeona archive mode : " + << XEONA_ARCHIVE_MODE + << std::endl; + + std::cout << "DT extension mode : " + << DT_CODE + << std::endl; + +#if (XEONA_ARCHIVE_MODE >= 2) + std::string ext = "xml"; +#else + std::string ext = "txt"; +#endif + std::string filename(boost::archive::tmpdir()); filename += "/testfile"; + filename += "."; + filename += ext; + + std::cout << "testfile : " + << filename + << "\n" + << std::endl; // create a new shared pointer to ta new object of type A boost::shared_ptr<A> spa(new A); @@ -94,9 +151,21 @@ // serialize it { std::ofstream ofs(filename.c_str()); + +#if (XEONA_ARCHIVE_MODE >= 2) + boost::archive::xml_oarchive oa(ofs); +#else boost::archive::text_oarchive oa(ofs); +#endif + +#if (XEONA_ARCHIVE_MODE >= 1) + oa << boost::serialization::make_nvp("spa", spa); + oa << boost::serialization::make_nvp("spa1", spa1); +#else oa << spa; oa << spa1; +#endif + } // reset the shared pointer to NULL // thereby destroying the object of type A @@ -108,17 +177,28 @@ { // open the archive std::ifstream ifs(filename.c_str()); + +#if (XEONA_ARCHIVE_MODE >= 2) + boost::archive::xml_iarchive ia(ifs); +#else boost::archive::text_iarchive ia(ifs); +#endif - // restore the schedule from the archive +#if (XEONA_ARCHIVE_MODE >= 1) + ia >> boost::serialization::make_nvp("spa", spa); + ia >> boost::serialization::make_nvp("spa1", spa1); +#else ia >> spa; ia >> spa1; +#endif + } display(spa, spa1); spa.reset(); spa1.reset(); - std::cout << std::endl; +#if (DT_CODE >= 1) + std::cout << std::endl; std::cout << "New tests" << std::endl; @@ -131,17 +211,29 @@ // serialize it { std::ofstream ofs(filename.c_str()); + +#if (XEONA_ARCHIVE_MODE >= 2) + boost::archive::xml_oarchive oa(ofs); +#else boost::archive::text_oarchive oa(ofs); +#endif oa.register_type(static_cast(NULL)); - oa.register_type( - static_cast< - boost::detail::sp_counted_base_impl< - B *, boost::checked_deleter - > * - >(NULL) - ); +// oa.register_type( +// static_cast< +// boost::detail::sp_counted_base_impl< +// B *, boost::checked_deleter +// > * +// >(NULL) +// ); + +#if (XEONA_ARCHIVE_MODE >= 1) + oa << boost::serialization::make_nvp("spa", spa); + oa << boost::serialization::make_nvp("spa1", spa1); +#else oa << spa; oa << spa1; +#endif + } // reset the shared pointer to NULL // thereby destroying the object of type B @@ -153,25 +245,40 @@ { // open the archive std::ifstream ifs(filename.c_str()); + +#if (XEONA_ARCHIVE_MODE >= 2) + boost::archive::xml_iarchive ia(ifs); +#else boost::archive::text_iarchive ia(ifs); +#endif - // restore the schedule from the archive ia.register_type(static_cast(NULL)); - ia.register_type( - static_cast< - boost::detail::sp_counted_base_impl< - B *, boost::checked_deleter - > * - >(NULL) - ); +// ia.register_type( +// static_cast< +// boost::detail::sp_counted_base_impl< +// B *, boost::checked_deleter +// > * +// >(NULL) +// ); + +#if (XEONA_ARCHIVE_MODE >= 1) + ia >> boost::serialization::make_nvp("spa", spa); + ia >> boost::serialization::make_nvp("spa1", spa1); +#else ia >> spa; ia >> spa1; +#endif + } display(spa, spa1); + +#endif // DT code + /////////////// - std::remove(filename.c_str()); + // std::remove(filename.c_str()); // obj of type A gets destroyed // as smart_ptr goes out of scope return 0; } + --- Robbie Morrison PhD student -- policy-oriented energy system simulation Institute for Energy Engineering (IET) Technical University of Berlin (TU-Berlin), Germany University email (redirected) : morrison(a)iet.tu-berlin.de Webmail (preferred) : robbie(a)actrix.co.nz [from IMAP client]

1 0

certain headers missing
by Dragos Sbarlea 21 Aug '07

21 Aug '07

Hello! I am a new Boost user and my question might seem dumb, but please try to help me. I installed boost and I can run the example posted on the boost getting started page successfully, but when I try to use Boost.Process i get an error that the header fiel does not exist. Looking in the boost include files, i see there is no such file as process.hpp and no folder called process ... Where do I do something wrong? (working on Linux with boost from ubuntu 7.04 repos) Thank you for your time! ____________________________________________________________________________________ Be a better Heartthrob. Get better relationship answers from someone who knows. Yahoo! Answers - Check it out. http://answers.yahoo.com/dir/?link=list&sid=396545433

2 1

boost assign: insufficent type error.
by chun ping wang 20 Aug '07

20 Aug '07

heres the code. template <class T> class next { public: next(const int& k) : k_(k), count(0) {} std::complex<T> operator()() { return std::complex<T>(((2.0*PI*k_/Random::randint(k_, 2*k_))*(++count)), 0); } private: static const double PI = 3.141592654; int k_; int count; }; when i tried to do boost::assign::list_of<std::complex<T> >.repeat_func(num_elems, next<T>(num_elems)); I get an error about insuffiecnet contextual information to determine type.

1 1

[boost.iostream & Boost Windows Installer 1.34.1] Trouble during linking
by Marc Viala 20 Aug '07

20 Aug '07

Hi, I've recently downloaded the new Boost 1.34.1 Windows Installer and tried to use it but I've met some linking troubles in conjunction with Boost.Iostream & Zlib compression scheme. To explain that, I've just tried to compile w/ VC++7.1 this code snippet: #include <boost/iostreams/filtering_streambuf.hpp> #include <boost/iostreams/copy.hpp> #include <boost/iostreams/filter/gzip.hpp> #include <iostream> #include <sstream> namespace io = boost::iostreams ; // Zlib compression void compress(std::istream& is, std::ostream& os) { io::filtering_streambuf<io::output> out ; out.push(io::gzip_compressor()) ; out.push(os) ; io::copy(is, out) ; } void main() { } The VC++ linker complains that "boost_zlib-vc71-mt-gd-1_34_1.lib" library can't be opened from the Boost installation library path. I've checked it and didn't find any "boost_zlib*" library in the distribution. I've read the "Getting started documentation" and I've found "no specific configuration" for Boost.Iostream with Zlib. I've surely missed something but... I've also went through the boost user-list archive unsuccessfully. Any help or suggestion will be welcomed Marc Viala

1 0

boost bind beginner throw problem
by Taglioretti Roberto 20 Aug '07

20 Aug '07

Hi, I have a problem with boot bind, in a my class there is this member: void test(int i) throw(Error); If I use bind(&test,obj,_1); I have a compilation error, instead if I change the member in void test(int i); all it works. Could someone help me to use bind with my original member ? I do not understand where is the problem. Thanks SO: windows XP SP2 compiler: VC 7.1 boot version: 1.34.1 -- Roberto *sono affetto da discromatopsia, per favore evitate l'invio di mail o allegati colorati* *I have dyschromatopsia, please do not send coloured text or email and attach*

2 1

ICU and Boost Regex
by Sudarshan Gaikaiwari 20 Aug '07

20 Aug '07

Hello Boost Experts I am trying to use Boost Regex to replace the java.util.regex package. I want to use the Unicode Regular Expressions and need to link with the ICU libraries. However I want to keep the size of my program as small as possible. What components of ICU are essential for Boost regex? What is the ICU configuration that would lead to the smallest ICU binaries that can still be usable by Boost regex? Thanks regards Sudarshan -- Sudarshan Gaikaiwari www.sudarshan.org sudarshan(a)acm.org

2 1

[Fwd: Having trouble with boost thread library]
by Fei Liu 20 Aug '07

20 Aug '07

3 3

serialization - portability
by Stefaan 20 Aug '07

20 Aug '07

Hi! I'm having an issue with archive portability. As I'm quite new to the internals of boost, I hope my attempt at pinpointing the problem is sensible: #include <iostream> #include <boost/serialization/vector.hpp> int main() { std::cerr << boost::serialization::implementation_level <std::vector <long long> >::value << std::endl; return 0; } built on a x86_64 platform prints out "3", on a i386 platform it prints out "2". I tested this both with boost 1.33.1 and 1.34.1. It is my guess that it causes the serialization of the used type to result in a larger archive on x86_64 than on i386. (Which is the original problem that led me to discover this) So my question is: is this the result of a bug in boost? If not, then what is the explanation of this difference? Using linux-2.6 with gcc. Thanks, Stefaan

3 2

Newbie needs yet more help with serialization - BOOST_SERIALIZATION_SPLIT_FREE
by Hector C. 20 Aug '07

20 Aug '07

Hi all, I don't understand why the following code doesn't compile. It gives an strange error: "missing type specifier - int assumed. Note: C++ does not support default-int" Any ideas? --Hector C. #define tpath boost::filesystem::wpath template< class Archive > void save( Archive & x_Stream, const tpath & x_Path, const unsigned int a_Version ) {} BOOST_SERIALIZATION_SPLIT_FREE(tpath) BOOST_CLASS_TRACKING(tpath, boost::serialization::track_never) int wmain(int argc, tchar * argv[]) { tpath tt; std::ofstream off(_T("test.txt"), std::ios_base::binary); boost::archive::binary_oarchive oa((std::ostream &)off); oa << tt; return 0; } ____________________________________________________________________________________ Looking for a deal? Find great prices on flights and hotels with Yahoo! FareChase. http://farechase.yahoo.com/

2 2

Compiling problem, Intel Compiler 9.1, Boost 1.34.1
by Notger Heinz 20 Aug '07

20 Aug '07

Dear community: I have a problem compiling with Intel 9.1 and Boost 1.34.1. It quits with error message, that says it was unable to find the lib libboost_thread-iw-mt-s-1_34_1.lib. Please, can anyone help me with this? Thank you very much in advance N. Heinz.

1 0

Still cannot cross-build boost libs
by Bruce Reid 20 Aug '07

20 Aug '07

I am trying to use linux-x86 platform to cross-build for linux-ppc. I have followed Vladimir’s suggestion to specify my cross-compiler/archiver by updating user-config.jam with: using gcc : : /path/to/my/linux-ppc-g++ : <archiver>/path/to/my/linux-ppc-ar ; I have confirmed this works IF I build one of the [header-only] example programs. This proves that user-config.jam (located in my home directory) is being found, and the compiler/archiver are specified correctly, since the resulting executable runs on the correct target (ppc) platform. However, when attempting to apply the same user-config.jam file to build boost/serialization, it appears my cross-compiler/archiver directives are ignored, and the resulting libraries are in the native x86 format, since attempting to build a program with one of them using my ppc-g++ compiler produces a spew of link errors. Modifying my makefile to use the native g++ compiler permits a successful linkage with the boost/serialization library, and the resulting executable runs fine on the x86 platform. The command I used to build boost/serialization is: bjam --toolset=gcc --with-serialization --prefix=/my/prefix/path --exec-prefix=/my/exec-prefix/path/linux_ppc --libdir=/my/exec-prefix/path/linux_ppc/lib install I also saved the output from the build, but can’t see any clues to explain where things went wrong. Any ideas why I seem to be so close, but still cannot produce boost library binaries for the desired target platform?

5 10

Re: [Boost-users] Serialization newbie needs help
by Dominick Layfield 19 Aug '07

19 Aug '07

Frank Birbacher wrote: > I now noticed that the link I posted does not reference excatly what I > meant to point at. Your code makes me think that you have not read what > I wanted you to read. Here it goes. > > READ THIS: > > http://www.boost.org/libs/serialization/doc/rationale.html#trap Well, Hector may not have read this, but I did! And it seems that I have the same problem as him. If I make the object I want to serialize a const, the (completely incomprehensible) compile error goes away. Any chance this could be added to a boost::serialization FAQ? It appears that I have a choice between (i) doing a const_cast on every object I want to save, and (ii) inserting a BOOST_CLASS_TRACKING(XXX, boost::serialization::track_never) line into my source code. Both are ugly, and although the former might be safe, it certainly looks dangerous! The "Compile time trap" section of the documentation doesn't actually explain what "object tracking" is all about. Neither (amusingly) does the Boost->Serialization->Reference->Special Considerations->Object Tracking section! After re-reading these sections several times, I realized that this is all related to serializing pointers. To my mind, it is not at all intuitive what should happen if I try to serialize a pointer to an object. What Boost::serialization seems to do is to serialize the object itself, but wrapped up in some magic that remembers the object was output/input through a pointer. i.e. if I create a my_class object, then output a pointer to the object, the object itself is output, and when I come to input the pointer, the library silently creates an object of type my_class, then puts a pointer to the object into my pointer. Is that about right? If so, this is (1) not transparent, and (2) seems ludicrously complex. As alluded to in the documentation, this creates a morass of problems (object-tracking, memory leaks etc.). Having said that, I have to applaud the tour-de-force of C++ wizardry required to make all of this magic work. To quote Bjarne Stroustrup, "...but you have to be very clever. If any of you have seen some of the Boost stuff, you don't want to be that clever!" (from his recent Waterloo talk) It seems to me that a cleaner, simpler (and less ambitious) solution would just be to make serialization of pointers an error. What on earth does it actually mean to serialize a pointer? And why would I want to do such a thing, anyway? -- Dominick

3 2

shared_ptr and thread safety
by gast128 19 Aug '07

19 Aug '07

Dear all, it is already posted a dozen times, but still I do not get it. I understand that if you have a class, the shared_ptr will not make this thread safe. That's fair. Non const operations accessed by different threads should still be guarded (and probably their const versions then also). But what about the shared_ptr itself. From the doc's (http://www.boost.org/libs/smart_ptr/shared_ptr.htm#ThreadSafety) I read that reading and writing to the shared_ptr object (not the pointee) is safe: 'A shared_ptr instance can be "read" (accessed using only const operations) simultaneously by multiple threads. Different shared_ptr instances can be "written to" (accessed using mutable operations such as operator= or reset) simultaneosly by multiple threads (even when these instances are copies, and share the same reference count underneath.)' However then a couple of examples are listed where both operator= and a dtor call are marked as undefined, and this is of course the most use (share a shared pointer over multiple threads and let them decide who finishes last, but this is then illegal?) >From the code I see that the ref counting is implemented through atomic inc's and dec's, and I would therefore expect that it is thread safe after all, since only the thread which makes the ref count 0 will be assigned the job of 'dispose', and the ref counting is thread safe. who can help this poor programmer... wkr, me

6 13

Looking for ScopeExit Reviews
by Jody Hagins 19 Aug '07

19 Aug '07

The review ends in three days (on Wednesday). The current collection of reviews is very small, thus I am asking for more reviews of this library. Thanks! >From the original announcement... The review period for Scope Exit Time Series, submitted by Alexander Nasonov, runs from Monday, August 13 until Wednesday, August 22. >From the documentation: Nowadays, every C++ developer is familiar with RAII technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. But there are times when writing a special class for such variable is not worth the effort. This is when ScopeExit macro comes into play. You put resource acquisition directly in your code and next to it you write a code that releases the resource. Note that ScopeExit uses PP macros and relies on Boost.Typeof. The latest version can is here: http://boost-consulting.com/vault/index.php?action=downloadfile&filename=sc… It's available also at http://tinyurl.com/2z6qg2 Online documentation is here: http://194.6.223.221/~nasonov/scope_exit-0.04/libs/scope_exit/doc/html/inde… >From the review guidelines here: http://boost.org/more/formal_review_process.htm ... Boost mailing list members are encouraged to submit Formal Review comments: * Publicly on the mailing list. * Privately to the Review Manager. Private comments to a library submitter may be helpful to her or him, but won't help the Review Manager reach a decision, so the other forms are preferred. What to include in Review Comments Your comments may be brief or lengthy, but basically the Review Manager needs your evaluation of the library. If you identify problems along the way, please note if they are minor, serious, or showstoppers. 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. Thanks in advance to every for your participation in this review.

1 0

Re: [Boost-users] regex_search on non-NULL terminated strings.
by Anders Dalvander 19 Aug '07

19 Aug '07

> The ideal interface would be: > 1) terminate when NULL character is found > 2) if NULL character not found, terminate when end marker is reached. char buffer[BUFFER_SIZE]; char* buffer_begin = buffer; char* buffer_end = buffer + BUFFER_SIZE; // TODO fill buffer with string. char* string_begin = buffer; char* string_end = std::find(buffer_begin, buffer_end, 0); // TODO call regex with string_begin and string_end. // Anders Dalvander

2 1

Re: [Boost-users] Serialization newbie needs help
by Hector C. 19 Aug '07

19 Aug '07

Robert Ramey wrote: > Actually, I've considered reviewing all the email in this list and > summarizing > the results in a section "Hints and Troubleshooting Tips". I think this > is useful and necessary and useful, but I just havent gotten around to it. > What about documentation using doxygen (in addition to what is already there)? I spent a lot of time reading the code to understand the usage of many things. For example, in current documentation there is no (semi-obvious) place for BOOST_SERIALIZATION_SPLIT. -- Hector C. ____________________________________________________________________________________ Yahoo! oneSearch: Finally, mobile search that gives answers, not web links. http://mobile.yahoo.com/mobileweb/onesearch?refer=1ONXIC

1 0

gregorian date and julian
by thom_schu＠gmx.de 18 Aug '07

18 Aug '07

Hi all, Can anyone tell me how to construct a date (gregorian) with a julian number ? I tried the constructor "date(special_values sv)" and it looked like it would work, but Im not sure if I can do this (what for is this constructor ?) So after taking a look in the source I found another possibility: greg_year_month_day ymd = gregorian_calendar::from_julian_day_number(2443510); date d(ymd); So are both ways right ? thanks in advance -- Der GMX SmartSurfer hilft bis zu 70% Ihrer Onlinekosten zu sparen! Ideal für Modem und ISDN: http://www.gmx.net/de/go/smartsurfer

2 1

Re: [Boost-users] Serialization newbie needs help
by Hector C. 18 Aug '07

18 Aug '07

Robert Ramey wrote: Dominick Layfield wrote: Frank Birbacher wrote: I now noticed that the link I posted does not reference excatly whatI meant to point at. Your code makes me think that you have not readwhat I wanted you to read. Here it goes.READ THIS:http://www.boost.org/libs/serialization/doc/rationale.html#trap Well, Hector may not have read this, but I did! C'mon, c'mon ;-) And it seems that Ihave the same problem as him. After I realized what the problem was, I found that it was rathercommon. If I make the object I want toserialize a const, the (completely incomprehensible) compile errorgoes away. Any chance this could be added to a boost::serializationFAQ? you mean change the section named "rationale" to "FAQ"? Perhaps the comments before the trap (code in the hpp file), shouldhave a hyperlink. It appears that I have a choice between (i) doing a const_cast onevery object I want to save, and (ii) inserting aBOOST_CLASS_TRACKING(XXX, boost::serialization::track_never) lineinto my source code. After reading the rationale, I saw that option (ii) allows me topostpone the fight (and I took it). What is more important is that thetrap is there to remember it. Perhaps another solution would be toprovide a base class for tracking objects. This way, instead of usingthe macro, one could derive from such class: class MyClass : private boost::serialization::trackme And this "trackme" class could have parameters in the constructor tosay whether it should be tracked: MyClass()::MyClass() : boost::serialization::trackme(never) {} or MyClass()::MyClass() : boost::serialization::trackme(selectively) {} etc .. This solution would be in addition to the const-reference andBOOST_CLASS_TRACKING ones. It seems to me that a cleaner, simpler (and less ambitious) solutionwould just be to make serialization of pointers an error. I wouldn't do that. C++ must allow me to shot myself if I'm notcareful!! --------------------------------- Take the Internet to Go: Yahoo!Go puts the Internet in your pocket: mail, news, photos & more.

1 0

Serialization newbie needs YET MORE help
by Hector C. 18 Aug '07

18 Aug '07

Hi all, Can anyone give any ideas why uncommenting the #define will give me errors? --Hector C. //#define GiveMeErrors #include <fstream> #ifdef GiveMeErrors # include <boost/archive/binary_woarchive.hpp> #else # include <boost/archive/binary_oarchive.hpp> #endif int main(int argc, char * argv[]) { #ifdef GiveMeErrors std::wofstream off("test.txt", std::ios_base::binary); boost::archive::binary_woarchive oa((std::wostream &)off); #else std::ofstream off("test.txt", std::ios::binary); boost::archive::binary_oarchive oa((std::ostream &)off); #endif return 0; } ---------------------------------- ____________________________________________________________________________________ Take the Internet to Go: Yahoo!Go puts the Internet in your pocket: mail, news, photos & more. http://mobile.yahoo.com/go?refer=1GNXIC

3 2

regex_search all
by izua 18 Aug '07

18 Aug '07

Hi everyone! I'm Richard from romania, and I'm pretty new to boost. I started using it because I need regex functionalities. Is there a regex_search functionality that will show me all found entries for the given regular expression? Something like preg_match_all in PHP? For example, if i have a regex ([0-9]+?[\W]+?) and the search string "abcd123.ef56[tab]essn" it would return me 2 arrays of arrays: first with an array 123 and ., second with 56 and tab. Thanks. -- View this message in context: http://www.nabble.com/regex_search-all-tf4285608.html#a12199378 Sent from the Boost - Users mailing list archive at Nabble.com.

3 7

asio example compile error
by ope 18 Aug '07

18 Aug '07

Hi, I try to compile the asio example at http://asio.sourceforge.net/boost_asio_0_3_7/libs/asio/doc/tutorial/tuttime… using boost svn trunk; as well as the the 1.34.1 The error attached occoured. What did I wrong? All headers seems to be found. Thanks, Olaf $ g++ -I boost-trunk/ t1.cpp ./boost-trunk/libs/system/src/error_code.cpp -o t1 boost-trunk/boost/asio/detail/bind_handler.hpp: In member function »void boost::asio::detail::binder1<Handler, Arg1>::operator()() [with Handler = void (*)(const boost::asio::error&), Arg1 = boost::system::error_code]«: boost-trunk/boost/asio/handler_invoke_hook.hpp:63: instantiated from »void boost::asio::asio_handler_invoke(Function, ...) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« boost-trunk/boost/asio/detail/handler_invoke_helpers.hpp:39: instantiated from »void asio_handler_invoke_helpers::invoke(const Function&, Context*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Context = void (*)(const boost::asio::error&)]« boost-trunk/boost/asio/detail/bind_handler.hpp:72: instantiated from »void boost::asio::detail::asio_handler_invoke(const Function&, boost::asio::detail::binder1<Handler, Arg1>*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Handler = void (*)(const boost::asio::error&), Arg1 = boost::system::error_code]« boost-trunk/boost/asio/detail/handler_invoke_helpers.hpp:39: instantiated from »void asio_handler_invoke_helpers::invoke(const Function&, Context*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Context = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« boost-trunk/boost/asio/detail/task_io_service.hpp:412: instantiated from »static void boost::asio::detail::task_io_service<Task>::handler_wrapper<Handler>::do_call(boost::asio::detail::task_io_service<Task>::handler_base*) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« boost-trunk/boost/asio/detail/task_io_service.hpp:392: instantiated from »boost::asio::detail::task_io_service<Task>::handler_wrapper<Handler>::handler_wrapper(Handler) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« boost-trunk/boost/asio/detail/handler_alloc_helpers.hpp:138: instantiated from »boost::asio::detail::handler_ptr<Alloc_Traits>::handler_ptr(boost::asio::detail::raw_handler_ptr<Alloc_Traits>&, Arg1&) [with Arg1 = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Alloc_Traits = boost::asio::detail::handler_alloc_traits<boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, boost::asio::detail::task_io_service<boost::asio::detail::epoll_reactor<false> >::handler_wrapper<boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code> > >]« boost-trunk/boost/asio/detail/task_io_service.hpp:180: instantiated from »void boost::asio::detail::task_io_service<Task>::post(Handler) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« boost-trunk/boost/asio/impl/io_service.ipp:125: instantiated from »void boost::asio::io_service::post(Handler) [with CompletionHandler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« boost-trunk/boost/asio/detail/deadline_timer_service.hpp:169: instantiated from »void boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::wait_handler<Handler>::operator()(const boost::system::error_code&) [with Handler = void (*)(const boost::asio::error&), Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Timer_Scheduler = boost::asio::detail::epoll_reactor<false>]« boost-trunk/boost/asio/detail/timer_queue.hpp:277: instantiated from »static void boost::asio::detail::timer_queue<Time_Traits>::timer<Handler>::invoke_handler(boost::asio::detail::timer_queue<Time_Traits>::timer_base*, const boost::system::error_code&) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« boost-trunk/boost/asio/detail/timer_queue.hpp:269: instantiated from »boost::asio::detail::timer_queue<Time_Traits>::timer<Handler>::timer(const typename Time_Traits::time_type&, Handler, void*) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« boost-trunk/boost/asio/detail/timer_queue.hpp:70: instantiated from »bool boost::asio::detail::timer_queue<Time_Traits>::enqueue_timer(const typename Time_Traits::time_type&, Handler, void*) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« boost-trunk/boost/asio/detail/epoll_reactor.hpp:325: instantiated from »void boost::asio::detail::epoll_reactor<Own_Thread>::schedule_timer(boost::asio::detail::timer_queue<Time_Traits>&, const typename Time_Traits::time_type&, Handler, void*) [with Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, bool Own_Thread = false]« boost-trunk/boost/asio/detail/deadline_timer_service.hpp:183: instantiated from »void boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::async_wait(boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::implementation_type&, Handler) [with Handler = void (*)(const boost::asio::error&), Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Timer_Scheduler = boost::asio::detail::epoll_reactor<false>]« boost-trunk/boost/asio/deadline_timer_service.hpp:153: instantiated from »void boost::asio::deadline_timer_service<TimeType, TimeTraits>::async_wait(typename boost::asio::detail::deadline_timer_service<TimeTraits, boost::asio::detail::epoll_reactor<false> >::implementation_type&, WaitHandler) [with WaitHandler = void (*)(const boost::asio::error&), TimeType = boost::posix_time::ptime, TimeTraits = boost::asio::time_traits<boost::posix_time::ptime>]« boost-trunk/boost/asio/basic_deadline_timer.hpp:374: instantiated from »void boost::asio::basic_deadline_timer<Time, TimeTraits, TimerService>::async_wait(WaitHandler) [with WaitHandler = void (*)(const boost::asio::error&), Time = boost::posix_time::ptime, TimeTraits = boost::asio::time_traits<boost::posix_time::ptime>, TimerService = boost::asio::deadline_timer_service<boost::posix_time::ptime, boost::asio::time_traits<boost::posix_time::ptime> >]« t1.cpp:15: instantiated from here boost-trunk/boost/asio/detail/bind_handler.hpp:39: Fehler: ungültige Initialisierung einer Referenz des Typs »const boost::asio::error&« von Ausdruck des Typs »boost::system::error_code«

1 0

oarchive and woarchive in different headers
by Hector C. 18 Aug '07

18 Aug '07

Hi all, Why is it that boost::archive::binary_oarchive and binary_woarchive require different headers? Isn't this against the custom in other headers, e.g. both string and wstring are defined in <string>. -- Hector C. ---------------------------------- ____________________________________________________________________________________ Be a better Globetrotter. Get better travel answers from someone who knows. Yahoo! Answers - Check it out. http://answers.yahoo.com/dir/?link=list&sid=396545469

1 0

Serialization library build problems
by Dominick Layfield 18 Aug '07

18 Aug '07

When I try to compile an application that uses the Boost serialization library, I get some compilation errors that I don't understand. I've taken the code, and trimmed it down to the simplest possible case that produces the same error. Here's the code: // Test of Boost serialization library #include <sstream> #include <boost/archive/text_oarchive.hpp> class test_t { public: int i; template <class Archive> void serialize(Archive& ar, const unsigned int version ) { ar & i; } test_t(int _i) : i(_i) {}; }; int main(void) { std::ostringstream oss; boost::archive::text_oarchive oa(oss); test_t test(1); oa << test; return 0; } When I compile this (gcc 4.1.2, Boost 1.33.1, under Fedora 7), I get the following error: g++ serialization_test.cpp -l boost_serialization /usr/include/boost/archive/detail/oserializer.hpp: In function ‘void boost::archive::save(Archive&, T&) [with Archive = boost::archive::text_oarchive, T = test_t]’: /usr/include/boost/archive/basic_text_oarchive.hpp:78: instantiated from ‘void boost::archive::basic_text_oarchive<Archive>::save_override(T&, int) [with T = test_t, Archive = boost::archive::text_oarchive]’ /usr/include/boost/archive/detail/interface_oarchive.hpp:78: instantiated from ‘Archive& boost::archive::detail::interface_oarchive<Archive>::operator<<(T&) [with T = test_t, Archive = boost::archive::text_oarchive]’ serialization_test.cpp:21: instantiated from here /usr/include/boost/archive/detail/oserializer.hpp:567: error: invalid application of ‘sizeof’ to incomplete type ‘boost::STATIC_ASSERTION_FAILURE<false>’ Can someone explain to me WTF is going on? That error makes absolutely no sense at all to me, and I'm at my wits end! Thanks, -- Dominick

2 1

Serialization newbie needs help
by Hector C. 18 Aug '07

18 Aug '07

Hi all, I just cannot understand why the following code fails to compile. I have read the help files, did my Google, stared at it for hours, etc. But I cannot make sense. It compiles to the following message. Any ideas will be appreciated, --Hector C. ----MESSAGE---- // if your program traps here, it indicates taht your doing one of the following: // a) serializing an object of a type marked "track_never" through a pointer. // b) saving an non-const object of a type not markd "track_never) // Either of these conditions may be an indicator of an error usage of the // serialization library and should be double checked. See documentation on // object tracking. --END MESSAGE-- ----CODE---- #include <iomanip> #include <iostream> #include <fstream> #include <string> #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/serialization/base_object.hpp> #include <boost/serialization/utility.hpp> #include <boost/serialization/list.hpp> using namespace std; class A { public: string m; A(){}; private: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & m; } }; int main(int argc, char * argv[]) { A a; { ofstream off("test.txt"); boost::archive::text_oarchive oa(off); //Uncommenting any of the following lines //produces compilation errors //oa << a; //oa << (const A) a; } return 0; } ---END CODE--- ---------------------------------- ____________________________________________________________________________________ Building a website is a piece of cake. Yahoo! Small Business gives you all the tools to get online. http://smallbusiness.yahoo.com/webhosting

3 4

where is Accumulators library?
by Frank Birbacher 17 Aug '07

17 Aug '07

Hi! The Accumulators library from Eric Niebler has been accepted for boost on February 19th. Now I cannot find evidence anywhere in boost: - neither the release has it - nor the CVS - nor the sandbox SVN I want to use this library. How? Frank

6 16

wide char i/o problem.
by chun ping wang 17 Aug '07

17 Aug '07

while trying to compile boost i get several failure. ...failed gcc.compile.c++ bin.v2\libs\serialization\build\gcc-mingw-3.4.5\releas e\link-static\runtime-link-static\text_wiarchive.o... gcc.compile.c++ bin.v2\libs\serialization\build\gcc-mingw-3.4.5\release\link-sta tic\runtime-link-static\text_woarchive.o libs\serialization\src\text_woarchive.cpp:13:2: #error "wide char i/o not suppor ted on this platform" "C:/mingw/bin/gcc" -ftemplate-depth-128 -O3 -finline-functions -Wno-inline -Wall -DBOOST_ALL_NO_LIB=1 -DNDEBUG -I"." -c -o " bin.v2\libs\serialization\bui ld\gcc-mingw-3.4.5\release\link-static\runtime-link-static\text_woarchive.o" "li bs\serialization\src\text_woarchive.cpp" ...failed gcc.compile.c++ bin.v2\libs\serialization\build\gcc-mingw-3.4.5\releas e\link-static\runtime-link-static\text_woarchive.o... gcc.compile.c++ bin.v2\libs\serialization\build\gcc-mingw-3.4.5\release\link-sta tic\runtime-link-static\xml_wgrammar.o libs\serialization\src\xml_wgrammar.cpp:14:2: #error "wide char i/o not supporte d on this platform" is their any ways for fix around this? using gcc mingw 3.4.5

6 7

[boost-users] boost assignment problem on non primitive type.
by chun ping wang 17 Aug '07

17 Aug '07

Question 1. std::vector<Roles> vr; the constructor for Roles: enum Role { .....}; explicit Roles (const std::string& usr, const Role& r); How would I use boost::assign::list_of to assign a vector of Roles instead of doing regular vector push_back. Question 2. Related. I have a Hash map i.e. boost::unordered_map<std::string, compositionType> and i want to use boost::map_list_of how would i do that. Question 3. trying to use operator += in boost::assignment i get error specifying unknown types. typedef boost::function<std::vector<int>(std::vector<int>)> sortfunc; std::vector<sortfunc> function_list; // quicksort random function_list += (&quicksort<QSTYPE(RANDOM), int, std::vector>) // quicksort median (&quicksort<QSTYPE(MEDIAN), int, std::vector>) // error here. // quicksort mediantriple (&quicksort<QSTYPE(MEDIANTRIPLE), int, std::vector>) // merge sort (&mergesort<int, std::vector>) // heap sort (&heapsort<int, std::vector>) // selection sort (&selection_sort<int, std::vector>) // standard sort (&standard_sort<int, std::vector>); Thanks for any help in advanced.

2 2

Re: [Boost-users] Time Series review results
by David Abrahams 17 Aug '07

17 Aug '07

on Fri Aug 17 2007, John Phillips <phillips-AT-delos.mps.ohio-state.edu> wrote: > list. However, for the sake of easy > reference I will list the major points and my current understanding of > what to do about them below. The order in which the points are presented > should not be taken as a rating of importance: it is just the order I > made notes about them as I reviewed the discussion. > <snip> > 32) Consider whether users need access to the metafunctions used to > determine return types. If so, consider how they could be exposed in a > user friendly way. If I may, 33) The PropertyMap concept used in the library needs to be renamed or reconceived to avoid clashing with the Boost PropertyMap library. This one is my fault, which is why I'm very conscious of it. -- Dave Abrahams Boost Consulting http://www.boost-consulting.com The Astoria Seminar ==> http://www.astoriaseminar.com

1 0

How to compile Boost for use with MinGW in Linux
by Ravi kumar Singh 17 Aug '07

17 Aug '07

I want to use Boost libraries with my MinGW compiler installed in my Linux Desktop, since I want to cross-compile a few programs for ms-windows. Though I have Boost installed in my system for native compilation, but I am unable to compile it for MinGW. Recently I have tried to compile Boost for MinGW, first by executing the following commands :- export CC=i586-mingw32msvc-gcc export CXX=i586-mingw32msvc-c++ export LD=i586-mingw32msvc-ld export AR=i586-mingw32msvc-ar export AS=i586-mingw32msvc-as export NM=i586-mingw32msvc-nm export STRIP=i586-mingw32msvc-strip export RANLIB=i586-mingw32msvc-ranlib export DLLTOOL=i586-mingw32msvc-dlltool export OBJDUMP=i586-mingw32msvc-objdump export RESCOMP=i586-mingw32msvc-windres and then :- ./configure make but it still produced native libraries..... Please tell me how to achieve that, or if you have any link where I can find proper instructions to do so. Thanks --------------------------------- Why delete messages? Unlimited storage is just a click away.

1 0

[statechart] using events for passing information
by "Christian Bähnisch" 17 Aug '07

17 Aug '07

Hello, I wonder if it is possible to use events for passing in data to states. I even cannot find some hints in the statechart documentation how to determine in some state which event caused a transistion to the this state! regards, chris -- Der GMX SmartSurfer hilft bis zu 70% Ihrer Onlinekosten zu sparen! Ideal für Modem und ISDN: http://www.gmx.net/de/go/smartsurfer

3 3

Passing user defined visitor for breadth_first_search
by Sourabh 17 Aug '07

17 Aug '07

Hi, I am using the boost graph (adjacency_list) and want to perform BFS on that. I am constructing the graph, passing VertexProperty as a structure (bundled_properties). When I try to modify the structure in my own bfs visitior (in the overriden function discover_vertex), the compiler says the structure (representing the vertex property) is readonly. I had to switch to const_cast of that structure, but it is not elegant. Can anyone help me through this? Regards, Sourabh

2 1

Boost.Test Documentation
by James Hamlin 17 Aug '07

17 Aug '07

Hi, I've begun using Boost.Test to construct test suites for a project, and it looks like it does a great job and is full of nice features (I really like the auto unit tests). But I have a big complaint: the documentation is pretty poor. I had a hard time getting a simple example off the ground, because it wasn't clear that I had to link to parts of the library. This was a surprise since most of Boost is templated and so is available entirely through the headers. I had to dig a bit to find the comment about the header that includes the main() code and other concrete functions. In addition, many of the examples are missing, and some of those that are available require the linking I mentioned but fail to note this, adding to my initial confusion. Lastly, the English grammar is very rough in parts, and while I understand that English may not be the primary language of the author, it can be a big hurdle to get started using the library when one has to grapple with the documentation to understand the intentions of the author. I don't mean to rant - the library is great, and I've already found it useful - but I'd love to get more out of it, and clean, clear, and thorough documentation will get me and others started with much less head scratching and frustration.<boost-test%20at%20emailaccount%20dot%20com%20%28please%20unobscure%29> Sincerely, James Hamlin Postscript: This is Boost-users, but I assume Gennadiy Rozental or somebody else with the knowledge and ability to update the documentation will see this message.

8 17

[multi_array]BOOST_NO_SFINAE Warnings
by Mark Ruzon 16 Aug '07

16 Aug '07

I recently upgraded to 1.34.1, gcc 3.4.6, and certain new changes in multi_array don't make sense to me: In view.hpp: template <class BaseList> #ifdef BOOST_NO_SFINAE void #else typename disable_if<typename boost::is_integral<BaseList>::type,void >::type #endif reindex(const BaseList& values) { boost::function_requires< detail::multi_array::CollectionConcept<BaseList> >(); boost::detail::multi_array:: copy_n(values.begin(),num_dimensions(),index_base_list_.begin()); origin_offset_ = this->calculate_indexing_offset(stride_list_,index_base_list_); } multi_array_ref.hpp has a similar function except for the last function call. Both give me warnings because BOOST_NO_SFINAE is not defined, and so reindex has a non-void return type but does not actually return anything. I can get rid of it by #defining this constant, but it seems like a bug in the code. Will someone more knowledgeable shed some light on this, please? Do I need to #define BOOST_NO_SFINAE? Thanks, Mark Ruzon P.S. Apologies if this is the second post asking this question.

1 0

[iostreams] file sink/source and wide char paths?
by Michael Ellery 16 Aug '07

16 Aug '07

it looks like the file_sink and file_source classes in iostreams take std::string for the file path. Was this intentional? I'm not sure what the consensus is on wide char file system paths, but it seems like they are supported by the filesystem package, for instance. Should I just convert my wide char paths to narrow char when it comes to using them with file_sink/file_source -- or is there a better way? Thanks, Mike Ellery

1 0

Unregistered Class Exception - Boost Serialization
by Jason Gorski 16 Aug '07

16 Aug '07

Hello, I have been using the Boost Serialization libraries on a project of mine and so far they have worked very well. However, I have been unable to properly load derived objects using a base class pointer. The following code generates an unregistered class exception: #include <iostream> #include <sstream> #include <iomanip> #include <string> #include <sstream> #include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/export.hpp> class Base_Class { public: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { // empty } virtual void print()=0; }; class Derived_Class: public Base_Class { public: int i1; int i2; int i3; friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & boost::serialization::base_object<Base_Class>(*this); ar & i1; ar & i2; ar & i3; } void print(){ std::cout << "i am a derived class object" << std::endl; } }; BOOST_CLASS_EXPORT(Derived_Class) /***************************************** Main *****************************************/ int main() { Derived_Class derived_send; derived_send.i1=12; derived_send.i2=13; derived_send.i3=14; Base_Class * base_ptr; Derived_Class * derived_recv; // save derived class std::ostringstream output_stream; boost::archive::text_oarchive output_archive( output_stream ); output_archive & derived_send; // load using base class ptr std::istringstream input_stream( output_stream.str() ); boost::archive::text_iarchive input_archive( input_stream ); input_archive & base_ptr; derived_recv = (Derived_Class*) base_ptr; derived_recv->print(); } From reading the documentation, it seems as if this should work fine. Am I missing something? Thanks in advance, Jason -- Jason Gorski Research Engineer Oasis Advanced Engineering, Inc. (248)373-9800 x 269 gorski(a)OasisAdvancedEngineering.com

2 3

asio example compile error
by ope 16 Aug '07

16 Aug '07

Hi, I try to compile the asio example at http://asio.sourceforge.net/boost_asio_0_3_7/libs/asio/doc/tutorial/tuttime… using boost 1.34.0 with latest sf.com release of boost_asio in directory extra/boost and lib_system of asio is in directory build/lib. The error attached occoured. What did I wrong? All headers seems to be found. Thanks, Olaf $ g++ asio.cpp -o asio -I /usr/local/include/ -I extra/boost/ -L build/lib/ -static -lboost_system-gcc41-mt-0_1 extra/boost/boost/asio/detail/bind_handler.hpp: In member function »void boost::asio::detail::binder1<Handler, Arg1>::operator()() [with Handler = void (*)(const boost::asio::error&), Arg1 = boost::system::error_code]«: extra/boost/boost/asio/handler_invoke_hook.hpp:63: instantiated from »void boost::asio::asio_handler_invoke(Function, ...) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« extra/boost/boost/asio/detail/handler_invoke_helpers.hpp:39: instantiated from »void asio_handler_invoke_helpers::invoke(const Function&, Context*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Context = void (*)(const boost::asio::error&)]« extra/boost/boost/asio/detail/bind_handler.hpp:72: instantiated from »void boost::asio::detail::asio_handler_invoke(const Function&, boost::asio::detail::binder1<Handler, Arg1>*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Handler = void (*)(const boost::asio::error&), Arg1 = boost::system::error_code]« extra/boost/boost/asio/detail/handler_invoke_helpers.hpp:39: instantiated from »void asio_handler_invoke_helpers::invoke(const Function&, Context*) [with Function = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Context = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« extra/boost/boost/asio/detail/task_io_service.hpp:412: instantiated from »static void boost::asio::detail::task_io_service<Task>::handler_wrapper<Handler>::do_call(boost::asio::detail::task_io_service<Task>::handler_base*) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« extra/boost/boost/asio/detail/task_io_service.hpp:392: instantiated from »boost::asio::detail::task_io_service<Task>::handler_wrapper<Handler>::handler_wrapper(Handler) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« extra/boost/boost/asio/detail/handler_alloc_helpers.hpp:138: instantiated from »boost::asio::detail::handler_ptr<Alloc_Traits>::handler_ptr(boost::asio::detail::raw_handler_ptr<Alloc_Traits>&, Arg1&) [with Arg1 = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Alloc_Traits = boost::asio::detail::handler_alloc_traits<boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, boost::asio::detail::task_io_service<boost::asio::detail::epoll_reactor<false> >::handler_wrapper<boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code> > >]« extra/boost/boost/asio/detail/task_io_service.hpp:180: instantiated from »void boost::asio::detail::task_io_service<Task>::post(Handler) [with Handler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>, Task = boost::asio::detail::epoll_reactor<false>]« extra/boost/boost/asio/impl/io_service.ipp:125: instantiated from »void boost::asio::io_service::post(Handler) [with CompletionHandler = boost::asio::detail::binder1<void (*)(const boost::asio::error&), boost::system::error_code>]« extra/boost/boost/asio/detail/deadline_timer_service.hpp:169: instantiated from »void boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::wait_handler<Handler>::operator()(const boost::system::error_code&) [with Handler = void (*)(const boost::asio::error&), Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Timer_Scheduler = boost::asio::detail::epoll_reactor<false>]« extra/boost/boost/asio/detail/timer_queue.hpp:243: instantiated from »static void boost::asio::detail::timer_queue<Time_Traits>::timer<Handler>::invoke_handler(boost::asio::detail::timer_queue<Time_Traits>::timer_base*, const boost::system::error_code&) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« extra/boost/boost/asio/detail/timer_queue.hpp:234: instantiated from »boost::asio::detail::timer_queue<Time_Traits>::timer<Handler>::timer(const typename Time_Traits::time_type&, Handler, void*) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« extra/boost/boost/asio/detail/timer_queue.hpp:68: instantiated from »bool boost::asio::detail::timer_queue<Time_Traits>::enqueue_timer(const typename Time_Traits::time_type&, Handler, void*) [with Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>]« extra/boost/boost/asio/detail/epoll_reactor.hpp:325: instantiated from »void boost::asio::detail::epoll_reactor<Own_Thread>::schedule_timer(boost::asio::detail::timer_queue<Time_Traits>&, const typename Time_Traits::time_type&, Handler, void*) [with Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Handler = boost::asio::detail::deadline_timer_service<boost::asio::time_traits<boost::posix_time::ptime>, boost::asio::detail::epoll_reactor<false> >::wait_handler<void (*)(const boost::asio::error&)>, bool Own_Thread = false]« extra/boost/boost/asio/detail/deadline_timer_service.hpp:183: instantiated from »void boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::async_wait(boost::asio::detail::deadline_timer_service<Time_Traits, Timer_Scheduler>::implementation_type&, Handler) [with Handler = void (*)(const boost::asio::error&), Time_Traits = boost::asio::time_traits<boost::posix_time::ptime>, Timer_Scheduler = boost::asio::detail::epoll_reactor<false>]« extra/boost/boost/asio/deadline_timer_service.hpp:153: instantiated from »void boost::asio::deadline_timer_service<TimeType, TimeTraits>::async_wait(typename boost::asio::detail::deadline_timer_service<TimeTraits, boost::asio::detail::epoll_reactor<false> >::implementation_type&, WaitHandler) [with WaitHandler = void (*)(const boost::asio::error&), TimeType = boost::posix_time::ptime, TimeTraits = boost::asio::time_traits<boost::posix_time::ptime>]« extra/boost/boost/asio/basic_deadline_timer.hpp:374: instantiated from »void boost::asio::basic_deadline_timer<Time, TimeTraits, TimerService>::async_wait(WaitHandler) [with WaitHandler = void (*)(const boost::asio::error&), Time = boost::posix_time::ptime, TimeTraits = boost::asio::time_traits<boost::posix_time::ptime>, TimerService = boost::asio::deadline_timer_service<boost::posix_time::ptime, boost::asio::time_traits<boost::posix_time::ptime> >]« asio.cpp:15: instantiated from here extra/boost/boost/asio/detail/bind_handler.hpp:39: Fehler: ungültige Initialisierung einer Referenz des Typs »const boost::asio::error&« von Ausdruck des Typs »boost::system::error_code«

1 0

[Announcement] Boost joins the Software Freedom Conservancy
by Beman Dawes 16 Aug '07

16 Aug '07

Effective August 10th, 2007, Boost became a member project of the Software Freedom Conservancy, http://conservancy.softwarefreedom.org. This means that Boost is now part of a legal entity under US law, and tax-exempt under section 501(c)(3) of the US tax regulations. Although this doesn't have much short-term effect, it lets us move forward with BoostCon 2008 planning with less administrative delay. Long-term, being part of a non-profit organization allows Boost to continue to grow and prosper, and to raise money if that becomes useful. After considering the option of starting our own foundation (a huge amount of work), the Boost moderators decided that joining the Software Freedom Conservancy was a better option. The SFC provides the same legal abilities of a foundation at NO cost to the Boost project. It also minimizes the amount of legal and administrative hassles for project members -- allowing us to stay focused on technical matters rather than tax law. In addition, we are free to leave the SFC and create our own foundation at a later time if we decide that the SFC is not serving us well. Boost is not alone -- some other well known open source projects have also joined the SFC (eg: Samba, Wine). For those interested in the details, see a copy of the legal agreement at svn.boost.org/svn/boost/trunk/more/BoostSponsorshipAgreement.pdf I signed for Boost, since I was the founder and am the owner of the boost.org domain name. Dave Abrahams gets the credit for working out the details of the SFC agreement, with the help of the other moderators. --Beman

1 0

Boost Serialization tracking issues
by gast128 16 Aug '07

16 Aug '07

Dear all, I was trying to use the Boost Serialization library again, but I ran into a problem which cost me a full day. The Boost Serialization library is a very handy library, but often when I use it I run into problems which cost me days. This time I try to serialize just 'track_never' objects. First of all the compiler firewall which is built in the library does not work when using the nvp macro: void Foo() { boost::archive::xml_oarchive oa(...) SomeStruct s; oa << s; // compile time error oa << BOOST_SERIALIZATION_NVP(s); //ok } But this wasn't the real problem. I was looping to serialize non tracking objects: void Bla() { boost::archive::xml_oarchive oa(...) for (int i = 0; i < 1000; ++i) { const SomeStruct s; oa << s; } } However the library did track them by pointer due to a previous request to serialize a pointer. It decides this on a call to 'basic_serializer::serialized_as_pointer' deep in the library. struct SomeStructHolder { SomeStructHolder() : m_p(NULL){} template <class Archive> void serialize(Archive& ar, const unsigned int /*version*/) { ar & BOOST_SERIALIZATION_NVP(m_p); } const SomeStruct* m_p; }; somewhere else: void Bla() { boost::archive::xml_oarchive oa(...) const SomeStructHolder holder; oa << holder; } So this is again an unexpected property of the library. Maybe the ambition for automatic object tracking is too high, and specify it explicitly per class / per archiving operation would be more work for the user, but also clearer. And still the original problem was too find out if Boost Serialization could also be used on a per demand loading of (value-)objects: in my problem the final storage can be potential bigger than computer memory, so I was wondering if objects could be loaded on demand (instead of all in once). wkr, me

3 9

ScopeExit Review Reminder
by Jody Hagins 16 Aug '07

16 Aug '07

We have received only a few reviews so far. The review ends in less than a week, so time is running short. Thanks! >From the original announcement... The review period for Scope Exit Time Series, submitted by Alexander Nasonov, runs from Monday, August 13 until Wednesday, August 22. >From the documentation: Nowadays, every C++ developer is familiar with RAII technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. But there are times when writing a special class for such variable is not worth the effort. This is when ScopeExit macro comes into play. You put resource acquisition directly in your code and next to it you write a code that releases the resource. Note that ScopeExit uses PP macros and relies on Boost.Typeof. The latest version can is here: http://boost-consulting.com/vault/index.php?action=downloadfile&filename=sc… It's available also at http://tinyurl.com/2z6qg2 Online documentation is here: http://194.6.223.221/~nasonov/scope_exit-0.04/libs/scope_exit/doc/html/inde… >From the review guidelines here: http://boost.org/more/formal_review_process.htm ... Boost mailing list members are encouraged to submit Formal Review comments: * Publicly on the mailing list. * Privately to the Review Manager. Private comments to a library submitter may be helpful to her or him, but won't help the Review Manager reach a decision, so the other forms are preferred. What to include in Review Comments Your comments may be brief or lengthy, but basically the Review Manager needs your evaluation of the library. If you identify problems along the way, please note if they are minor, serious, or showstoppers. 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. Thanks in advance to every for your participation in this review.

1 0

[Fwd: boost serialization excessive warning messages]
by Fei Liu 16 Aug '07

16 Aug '07

1 0

Boost regex Java Regex package compatibility
by Sudarshan Gaikaiwari 16 Aug '07

16 Aug '07

Hello Boost Experts Here is my situation. Users write regular expressions which act as input to our programs and are used to perform matches. Currently the code base is Java and uses the java.util.regex package to handle regular expressions. I need to convert this code to C++ and intend to use boost regex. How compatible is boost regex with Java regex? I have looked at Java regex documentation here http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html to note the differences between Java regex and Perl 5 regexs. Are these the only with boost regex also? -- Sudarshan Gaikaiwari www.sudarshan.org sudarshan(a)acm.org

2 1

exceptions from regexp library usage
by Venkat Rangan 16 Aug '07

16 Aug '07

Hi, I get the following exception while using a boost regexp matching libraries (with Windows Visual Studio, 7.1 environment). Setup: static RegexClass::RegularExpression re_exp; bool CMyclass::parseExpression(string expression) { LoggerPtr logger = Logger::getRootLogger(); ostringstream oss; RegexClass::RegularExpression *re = &re_exp; re->Expression = expression; RegexClass::RegularExpression::ExpressionErrorCode eec = re->ParseExpression(); if (eec == RegexClass::RegularExpression::REG_NOERROR) { oss << "Parse successful: " << expression; logger->info(oss.str()); return true; } ... } Matching call: bool CMyClass::matchSpec(RegexClass::RegularExpression *pRe, const char *stringToMatch) { pRe->SetStringToMatch(stringToMatch); if (pRe->Match()) { return true; } return false; } Exception while using expression matcher on Windows Server 2003 Platforms: Exception Stack Trace 0x0343c900 0x00457374 boost::re_detail::reg_grep2<boost::re_detail::grep_search_predicate<std: :basic_string<char,std::char_traits<char>,std::allocator<char> >::iterator,boost::detail::allocator<char> >,std::basic_string<char,std::char_traits<char>,std::allocator<char> >::iterator,char,boost::regex_traits<char>,boost::detail::allocator<char >,boost::detail::allocator<char> > 0x00000044 0x0343c924 0x0045a65b boost::regex_search<std::basic_string<char,std::char_traits<char>,std::a llocator<char>>::iterator,boost::detail::allocator<char>,char,boost::reg ex_traits<char>,boost::detail::allocator<char> > 0x0000003b 0x0343c970 0x0045ae66 RegexClass::RegularExpression::Match 0x000001c6 Sometimes, I get the following exception: Stack Trace 0x037dc938 0x0045db6e RegexClass::RegularExpressionPimpl::GetMatchingInformation 0x0000027e 0x037dc970 0x0045af19 RegexClass::RegularExpression::Match 0x00000279 0x037dc9a0 0x004370b1 CMyClass::matchSpec 0x00000091 at myclass.cpp(349) Any help would be much appreciated. Thanks.

2 1

Link errors using Boost & STLPort with VC8
by Jason Ivey 16 Aug '07

16 Aug '07

I am attempting to compile and link a small test application using STLPort_5.1.3, boost_1_34_1 and MSVC8 sp1. Everything works fine when I don't have to link against any boost libraries. To test linking against the boost static libraries I wrote a simple little test app that used the boost::regex library and ran into errors. I am not completely sure that this is a boost issue but since I can compile and link programs without any problems that don't use boost binaries I wasn't sure of who else to turn to. The linker error I am getting is: 1>LINK : fatal error LNK1104: cannot open file 'stlportstld_x.5.1.lib' The problem is that all of the stlport libraries are named stlportstld.5.1.lib or similar. I did try to just rename the library to make it match but, of course, I got a boat load of unresolved external linker errors pointing to names such as "stlpdx_std::basic_string." Looking at a dumpbin output of the actual regex library it is linking against, libboost_regex-vc80-mt-sgdp-1_34_1.lib, I found linker directives of the form: /DEFAULTLIB:"stlportstld_x.5.1.lib" /DEFAULTLIB:"libcpmtd" /DEFAULTLIB:"LIBCMTD" /DEFAULTLIB:"OLDNAMES" I couldn't find anywhere that boost had put those directives in the libraries but I could be missing something so I also did a dumpbin of one of the stlport libraries, stlportd_static.5.1.lib, and only found the following linker directives: /DEFAULTLIB:"LIBCMTD" /DEFAULTLIB:"OLDNAMES" I have to believe there are at least a few companies out there who have replaced the shipping MSVC STL for testing purposes, if for no other reason, and are also using Boost so hopefully I'm just missing something obvious. Below are the steps I followed to compile both sets of libraries and the test application. Let me know if anything appears to be off or if there is simply a better/easier way. Thanks, Jason Ivey Open command prompt and run: "%VS80COMNTOOLS%\vsvars32.bat" STLPort_5.1.3 build\lib\configure -c msvc8 nmake /fmsvc.mak install Boost_1_34_1 edit tools\build\v2\user-config.jam added line 45 with using stlport : : d:\\build\\stlport\\stlport d:\\build\\stlport\\lib ; bjam --toolset=msvc stdlib=stlport --with-regex stage Build Test Application set include=d:\build\stlport\stlport;D:\build\boost_1_34_1;%include% set lib=d:\build\stlport\lib;D:\build\boost_1_34_1\stage\lib;%lib% call "%VS80COMNTOOLS%\..\IDE\devenv.exe" /useenv

2 2

function/bind - passing function pointer to C API
by Nicholas Yue 16 Aug '07

16 Aug '07

Hi, I am attempting to use Boost bind and function to help me pass a member function as a function pointer to the GLUT C-library. I have difficulty understanding the usage of bind and function in the Boost library. When I attempt to pass what I thought was a function pointer, the compiler indicated that it is actually not a function pointer. class MyGlut { public: MyGlut(); virtual ~MyGlut(); void loop(int argc, char **argv); void draw(void); void displayFunc(boost::function<void()> func); private: boost::function<void()> display_callback; }; void MyGlut::displayFunc(boost::function<void()> func) { glutDisplayFunc(func); // ERROR IN COMPILATION } void MyGlut::loop(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); glutCreateWindow("Hello World"); //glutDisplayFunc(redraw); // Original way to pass C-function pointer displayFunc( boost::bind(&MyGlut::draw, *this) ); } Regards

2 1

Need ideas...
by Noah Roberts 16 Aug '07

16 Aug '07

I am trying to generalize the concept of putting database data into boost::tuple objects. I'm thinking syntax similar to something like so: typedef boost::tuple<int, double, std::string> row; row r = SqlQuery<row>::run_query(db, "select * from x"); I imagine something like so being contained in the processing: TUPLE t; ... t.get<X>() = boost::lexical_cast< typename boost::tuples::element<X,TUPLE>::type >(data[X]); // data is char ** Where X is the index of the element and the entire tuple is iterated in this manner. I thought maybe there would be something in MPL that could help but I'm not seeing it. Anyone got any bright ideas?

5 7

BOOST pass an object to python code
by alex＠gorex.com.hk 16 Aug '07

16 Aug '07

Hello, I am new in this list. I would like to ask a quesiton about the linkage between BOOST and Python. I want to use C++ to trigger a Python code so that when I change anything inside Python, my C++ can know the changes and get the result back. So how can I pass an object from C++ to Python? and return the result? Here is the code that embedded the Class. class CppClass { public: int getNum() { return 7; } }; #include <boost/python.hpp> using namespace boost::python; int main( int argc, char ** argv ) { try { Py_Initialize(); object main_module(( handle<>(borrowed(PyImport_AddModule("__main__"))))); object main_namespace = main_module.attr("__dict__"); main_namespace["CppClass"] = class_<CppClass>("CppClass") .def("getNum",&CppClass::getNum); handle<> ignored(( PyRun_String( ""cpp = CppClass()\n" "print cpp.getNum()\n"", Py_file_input, main_namespace.ptr(), main_namespace.ptr() ) )); } catch( error_already_set ) { PyErr_Print(); } } Thanks

1 0

[OT] Stroustrup video on slashdot
by Christian Henning 15 Aug '07

15 Aug '07

Hi there, some of you might be interested in watching his talk. http://it.slashdot.org/it/07/08/13/0818238.shtml I found this interview with Bjarne quite interesting: ----------- Interviewer: Well, it's been a few years since you changed the world of software design, how does it feel, looking back? Stroustrup: Actually, I was thinking about those days, just before you arrived. Do you remember? Everyone was writing 'C' and, the trouble was, they were pretty damn good at it. Universities got pretty good at teaching it, too. They were turning out competent - I stress the word 'competent' - graduates at a phenomenal rate. That's what caused the problem. Interviewer: Problem? Stroustrup: Yes, problem. Remember when everyone wrote Cobol? Interviewer: Of course, I did too Stroustrup: Well, in the beginning, these guys were like demi-gods. Their salaries were high, and they were treated like royalty. Interviewer: Those were the days, eh? Stroustrup: Right. So what happened? IBM got sick of it, and invested millions in training programmers, till they were a dime a dozen. Interviewer: That's why I got out. Salaries dropped within a year, to the point where being a journalist actually paid better. Stroustrup: Exactly. Well, the same happened with 'C' programmers. Interviewer: I see, but what's the point? Stroustrup: Well, one day, when I was sitting in my office, I thought of this little scheme, which would redress the balance a little. I thought 'I wonder what would happen, if there were a language so complicated, so difficult to learn, that nobody would ever be able to swamp the market with programmers? Actually, I got some of the ideas from X10, you know, X windows. That was such a bitch of a graphics system, that it only just ran on those Sun 3/60 things. They had all the ingredients for what I wanted. A really diculously complex syntax, obscure functions, and pseudo-OO structure. Even now, nobody writes raw X-windows code. Motif is the only way to go if you want to retain your sanity. Interviewer: You're kidding...? Stroustrup: Not a bit of it. In fact, there was another problem. Unix was written in 'C', which meant that any 'C' programmer could very easily become a systems programmer. Remember what a mainframe systems programmer used to earn? Interviewer: You bet I do, that's what I used to do. Stroustrup: OK, so this new language had to divorce itself from Unix, by hiding all the system calls that bound the two together so nicely. This would enable guys who only knew about DOS to earn a decent living too. Interviewer: I don't believe you said that... Stroustrup: Well, it's been long enough, now, and I believe most people have figured out for themselves that C++ is a waste of time but, I must say, it's taken them a lot longer than I thought it would. Interviewer: So how exactly did you do it? Stroustrup: It was only supposed to be a joke, I never thought people would take the book seriously. Anyone with half a brain can see that object-oriented programming is counter-intuitive, illogical and inefficient. Interviewer: What? Stroustrup: And as for 're-useable code' - when did you ever hear of a company re-using its code? Interviewer: Well, never, actually, but... Stroustrup: There you are then. Mind you, a few tried, in the early days. There was this Oregon company - Mentor Graphics, I think they were called - really caught a cold trying to rewrite everything in C++ in about '90 or '91. I felt sorry for them really, but I thought people would learn from their mistakes. Interviewer: Obviously, they didn't? Stroustrup: Not in the slightest. Trouble is, most companies hush-up all their major blunders, and explaining a $30 million loss to the shareholders would have been difficult. Give them their due, though, they made it work in the end. Interviewer: They did? Well, there you are then, it proves O-O works. Stroustrup: Well, almost. The executable was so huge, it took five minutes to load, on an HP workstation, with 128MB of RAM. Then it ran like treacle. Actually, I thought this would be a major stumbling-block, and I'd get found out within a week, but nobody cared. Sun and HP were only too glad to sell enormously powerful boxes, with huge resources just to run trivial programs. You know, when we had our first C++ compiler, at AT&T, I compiled 'Hello World', and couldn't believe the size of the executable. 2.1MB Interviewer: What? Well, compilers have come a long way, since then. Stroustrup: They have? Try it on the latest version of g++ - you won't get much change out of half a megabyte. Also, there are several quite recent examples for you, from all over the world. British Telecom had a major disaster on their hands but, luckily, managed to scrap the whole thing and start again. They were luckier than Australian Telecom. Now I hear that Siemens is building a dinosaur, and getting more and more worried as the size of the hardware gets bigger, to accommodate the executables. Isn't multiple eritance a joy? Interviewer: Yes, but C++ is basically a sound language. Stroustrup: You really believe that, don't you? Have you ever sat down and worked on a C++ project? Here's what happens: First, I've put in enough pitfalls to make sure that only the most trivial projects will work first time. Take operator overloading. At the end of the project, almost every module has it, usually, because guys feel they really should do it, as it was in their training course. The same operator then means something totally different in every module. Try pulling that lot together, when you have a red or so modules. And as for data hiding. God, I sometimes can't help laughing when I hear about the problems companies have making their modules talk to each other. I think the word 'synergistic' was specially invented to twist the knife in a project manager's ribs. Interviewer: I have to say, I'm beginning to be quite appalled at all this. You say you did it to raise programmers' salaries? That's obscene. Stroustrup: Not really. Everyone has a choice. I didn't expect the thing to get so much out of hand. Anyway, I basically succeeded. C++ is dying off now, but programmers still get high salaries - especially those poor devils who have to maintain all this crap. You do realise, it's impossible to maintain a large C++ software module if you didn't actually write it? Interviewer: How come? Stroustrup: You are out of touch, aren't you? Remember the typedef? Interviewer: Yes, of course. Stroustrup: Remember how long it took to grope through the header files only to find that 'RoofRaised' was a double precision number? Well, imagine how long it takes to find all the implicit typedefs in all the Classes in a major project. Interviewer: So how do you reckon you've succeeded? Stroustrup: Remember the length of the average-sized 'C' project? About 6 months. Not nearly long enough for a guy with a wife and kids to earn enough to have a decent standard of living. Take the same project, design it in C++ and what do you get? I'll tell you. One to two years. Isn't that great? All that job security, just through one mistake of judgement. And another thing. The universities haven't been teaching 'C' for such a long time, there's now a shortage of decent 'C' programmers. Especially those who know nything about Unix systems programming. How many guys would know what to do with 'malloc', when they've used 'new' all these years - and never bothered to check the return code. In fact, most C++ programmers throw away their return codes. Whatever happened to good ol' '-1'? At least you knew you had an error, without bogging the thing down in all that 'throw' 'catch' 'try' stuff. Interviewer: But, surely, inheritance does save a lot of time? Stroustrup: Does it? Have you ever noticed the difference between a 'C' project plan, and a C++ project plan? The planning stage for a C++ project is three times as long. Precisely to make sure that everything which should be inherited is, and what shouldn't isn't. Then, they still get it wrong. Whoever heard of memory leaks in a 'C' program? Now finding them is a major industry. Most companies give up, and send the product out, knowing it leaks like a sieve, simply to avoid the expense of tracking them all down. Interviewer: There are tools... Stroustrup: Most of which were written in C++. Interviewer: If we publish this, you'll probably get lynched, you do realise that? Stroustrup: I doubt it. As I said, C++ is way past its peak now, and no company in its right mind would start a C++ project without a pilot trial. That should convince them that it's the road to disaster. If not, they deserve all they get. You know, I tried to convince Dennis Ritchie to rewrite Unix in C++. Interviewer: Oh my God. What did he say? Stroustrup: Well, luckily, he has a good sense of humor. I think both he and Brian figured out what I was doing, in the early days, but never let on. He said he'd help me write a C++ version of DOS, if I was interested. Interviewer: Were you? Stroustrup: Actually, I did write DOS in C++, I'll give you a demo when we're through. I have it running on a Sparc 20 in the computer room. Goes like a rocket on 4 CPU's, and only takes up 70 megs of disk. Interviewer: What's it like on a PC? Stroustrup: Now you're kidding. Haven't you ever seen Windows '95? I think of that as my biggest success. Nearly blew the game before I was ready, though. Interviewer: You know, that idea of a Unix++ has really got me thinking. Somewhere out there, there's a guy going to try it. Stroustrup: Not after they read this interview. Interviewer: I'm sorry, but I don't see us being able to publish any of this. Stroustrup: But it's the story of the century. I only want to be remembered by my fellow programmers, for what I've done for them. You know how much a C++ guy can get these days? Interviewer: Last I heard, a really top guy is worth $70 - $80 an hour. Stroustrup: See? And I bet he earns it. Keeping track of all the gotchas I put into C++ is no easy job. And, as I said before, every C++ programmer feels bound by some mystic promise to use every damn element of the language on every project. Actually, that really annoys me sometimes, even though it serves my original purpose. I almost like the language after all this time. Interviewer: You mean you didn't before? Stroustrup: Hated it. It even looks clumsy, don't you agree? But when the book royalties started to come in... well, you get the picture. Interviewer: Just a minute. What about references? You must admit, you improved on 'C' pointers. Stroustrup: Hmm. I've always wondered about that. Originally, I thought I had. Then, one day I was discussing this with a guy who'd written C++ from the beginning. He said he could never remember whether his variables were referenced or dereferenced, so he always used pointers. He said the little asterisk always reminded him. Interviewer: Well, at this point, I usually say 'thank you very much' but it hardly seems adequate. Stroustrup: Promise me you'll publish this. My conscience is getting the better of me these days. Interviewer: I'll let you know, but I think I know what my editor will say. Stroustrup: Who'd believe it anyway? Although, can you send me a copy of that tape? Interviewer: I can do that.

3 2

Having trouble with boost thread library
by Fei Liu 15 Aug '07

15 Aug '07

#ifndef UTILS_NETWORK_TCP_CONNECTION_HPP #define UTILS_NETWORK_TCP_CONNECTION_HPP namespace utils{ namespace thread{ template <typename shared_obj_type, typename thread_pool_type, typename serverlet_type> class tcp_connection{ private: int newsockfd; shared_obj_type obj; thread_pool_type pool; serverlet_type serverlet; bool initialized_; public: tcp_connection() : initialized_ (false) {} tcp_connection(int newsockfd, shared_obj_type obj, thread_pool_type pool, serverlet_type serverlet) : newsockfd(newsockfd), obj(obj), pool(pool), serverlet(serverlet), initialized_(true) { } bool initialized() { return initialized_; } bool initialize(int newsockfd, shared_obj_type obj, thread_pool_type pool, serverlet_type serverlet); void operator ()(); }; template <typename shared_obj_type, typename thread_pool_type, typename serverlet_type> bool tcp_connection<shared_obj_type, thread_pool_type, serverlet_type>::initialize (int newsockfd, shared_obj_type obj, thread_pool_type pool, serverlet_type serverlet) { this->newsockfd = newsockfd; this->obj = obj; this->pool = pool; this->serverlet = serverlet; initialized_ = true; return initialized_; } template <typename shared_obj_type, typename thread_pool_type, typename serverlet_type> void tcp_connection<shared_obj_type, thread_pool_type, serverlet_type>::operator() () { //if(initialized_) serverlet_type(newsockfd, obj); <---- causes error pool->release(); } } } #endif main.cpp: provides definition of serverlet_type #include "utils/thread/tcp_server.hpp" #include "utils/thread/thread_pool.h" #include <boost/shared_ptr.hpp> #include <vector> #include <iostream> typedef std::vector<int> shared_obj_type; typedef boost::shared_ptr<boost_thread::thread_pool> thread_pool_type; typedef void (*serverlet_type)(int, shared_obj_type); void servlet(int sock, shared_obj_type ){ std::cout << "got a new socket for a new connection: " << sock << std::endl; } int main(){ shared_obj_type x; thread_pool_type p( new boost_thread::thread_pool(20) ); utils::thread::tcp_server<shared_obj_type, thread_pool_type, serverlet_type> server; server.initialize(x, p, servlet, 10000, 5); boost::thread s(server); s.join(); } /root/cpp-utils-header-lib/include/utils/thread/tcp_connection.hpp: In member function `void utils::thread::tcp_connection<shared_obj_type, thread_pool_type, serverlet_type>::operator()() [with shared_obj_type = shared_obj_type, thread_pool_type = thread_pool_type, serverlet_type = void (*)(int, shared_obj_type)]': /usr/include/boost/function/function_template.hpp:155: instantiated from `static void boost::detail::function::void_function_obj_invoker0<FunctionObj, R>::invoke(boost::detail::function::function_buffer&) [with FunctionObj = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void]' /usr/include/boost/function/function_template.hpp:368: instantiated from `void boost::detail::function::basic_vtable0<R, Allocator>::init(FunctionObj, boost::detail::function::function_obj_tag) [with FunctionObj = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:298: instantiated from `void boost::detail::function::basic_vtable0<R, Allocator>::init(F) [with F = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:277: instantiated from `boost::detail::function::basic_vtable0<R, Allocator>::basic_vtable0(F) [with F = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:655: instantiated from `void boost::function0<R, Allocator>::assign_to(Functor) [with Functor = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:513: instantiated from `boost::function0<R, Allocator>::function0(Functor, typename boost::enable_if_c< boost::type_traits::ice_not< boost::is_integral<Functor>::value>::value, int>::type) [with Functor = utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>, R = void, Allocator = std::allocator<boost::function_base>]' /root/cpp-utils-header-lib/include/utils/thread/tcp_server.hpp:107: instantiated from `void utils::thread::tcp_server<shared_obj_type, thread_pool_type, serverlet_type, accept_fail_policy>::operator()() [with shared_obj_type = shared_obj_type, thread_pool_type = thread_pool_type, serverlet_type = void (*)(int, shared_obj_type), accept_fail_policy = utils::thread::default_accept_fail_policy]' /usr/include/boost/function/function_template.hpp:155: instantiated from `static void boost::detail::function::void_function_obj_invoker0<FunctionObj, R>::invoke(boost::detail::function::function_buffer&) [with FunctionObj = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void]' /usr/include/boost/function/function_template.hpp:368: instantiated from `void boost::detail::function::basic_vtable0<R, Allocator>::init(FunctionObj, boost::detail::function::function_obj_tag) [with FunctionObj = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:298: instantiated from `void boost::detail::function::basic_vtable0<R, Allocator>::init(F) [with F = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:277: instantiated from `boost::detail::function::basic_vtable0<R, Allocator>::basic_vtable0(F) [with F = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:655: instantiated from `void boost::function0<R, Allocator>::assign_to(Functor) [with Functor = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void, Allocator = std::allocator<boost::function_base>]' /usr/include/boost/function/function_template.hpp:513: instantiated from `boost::function0<R, Allocator>::function0(Functor, typename boost::enable_if_c< boost::type_traits::ice_not< boost::is_integral<Functor>::value>::value, int>::type) [with Functor = utils::thread::tcp_server<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type), utils::thread::default_accept_fail_policy>, R = void, Allocator = std::allocator<boost::function_base>]' tests/boost_tcp_server_test.cpp:24: instantiated from here /root/cpp-utils-header-lib/include/utils/thread/tcp_connection.hpp:61: error: functional cast expression list treated as compound expression /root/cpp-utils-header-lib/include/utils/thread/tcp_connection.hpp:61: warning: left-hand operand of comma has no effect /root/cpp-utils-header-lib/include/utils/thread/tcp_connection.hpp:61: error: cannot convert `((void)((utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>*)this)->utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>::newsockfd, ((utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>*)this)->utils::thread::tcp_connection<shared_obj_type, thread_pool_type, void (*)(int, shared_obj_type)>::obj)' from type `shared_obj_type' to type `void (*)(int, shared_obj_type)'

1 0

Update: application failed to initialize, bad jmp to malloc?
by David Daeschler 15 Aug '07

15 Aug '07

I'm sorry this post is so long, I'm looking for someone who may have experienced this, or knows enough about what I am rambling about to help me. I haven't been able to run our app built with MINGW for a week now, and It's starting to become a problem. This is a followup to a previous post entitled "Wrong DLL init routine being called?". I am starting a new post because it appears as if the stack traces I was getting before were wrong. I now have more information, and feel I am closer to solving this. When I try to load a test application I'm receiving the message: "The application failed to initialize properly (0xc0000005). Click on OK to terminate the application." I am not using auto-imports, so solutions referring to them have not helped me. I have always been winding up in malloc during the crashes I've been experiencing in calls to DLL initialization routines. I've been able to get a stack trace that lands up inside dllcrt1.c (the STATIC MINGW runtime) and shows me which call to malloc is segfaulting. The stack trace is as follows: #0 0x003e14a0 in malloc () #1 0x003e111c in DllMainCRTStartup@12 (hDll=0x3e0000, dwReason=1, lpReserved=0x22fd30) at dllcrt1.c:56 #2 0x7c9011a7 in ntdll!LdrSetAppCompatDllRedirectionCallback () from C:\WINDOWS\system32\ntdll.dll #3 0x003e0000 in ?? () #4 0x00000001 in ?? () #5 0x003e10c0 in __dll_exit () at dllcrt1.c:149 #6 0x00000000 in ?? () with frame 1 (inside dllcrt1.c) as: (gdb) f 1 #1 0x003e111c in DllMainCRTStartup@12 (hDll=0x3e0000, dwReason=1, lpReserved=0x22fd30) at dllcrt1.c:56 56 first_atexit = (p_atexit_fn*) malloc (32 * sizeof (p_atexit_fn)); Current language: auto; currently c (gdb) list 51 #endif 52 53 /* Initialize private atexit table for this dll. 54 32 is min size required by ANSI */ 55 56 first_atexit = (p_atexit_fn*) malloc (32 * sizeof (p_atexit_fn)); 57 if (first_atexit == NULL ) /* can't allocate memory */ 58 { 59 errno=ENOMEM; 60 return FALSE; Notice line 56. It seems innocent enough, how could a call to malloc be crashing? Well I called malloc from insidge gdb, and it worked fine, so I then dug further in and noticed that the malloc symbol that gdb is seeing is: (gdb) print malloc $1 = {<text variable, no debug info>} 0x40c780 <malloc> 0x40c780, okay, lets see a disassembly: Dump of assembler code for function malloc: 0x0040c780 <malloc+0>: jmp *0x41b1dc So there is a jump to 0x41b1dc, sure enough that lands us inside of: (gdb) disas 0x41b1dc Dump of assembler code for function _imp__malloc: 0x0041b1dc <_imp__malloc+0>: pop %es 0x0041b1dd <_imp__malloc+1>: les (bad),%eax 0x0041b1de <_imp__malloc+2>: ret $0x77 Ahh, import stub that leads us to: (gdb) disas _imp__malloc Dump of assembler code for function msvcrt!malloc: 0x77c2c407 <msvcrt!malloc+0>: mov %edi,%edi 0x77c2c409 <msvcrt!malloc+2>: push %ebp 0x77c2c40a <msvcrt!malloc+3>: mov %esp,%ebp 0x77c2c40c <msvcrt!malloc+5>: cmpl $0x0,0x77c62418 0x77c2c413 <msvcrt!malloc+12>: jne 0x77c2c420 <msvcrt!malloc+25> 0x77c2c415 <msvcrt!malloc+14>: call 0x77c1ef38 <msvcrt!__initenv+77> 0x77c2c41a <msvcrt!malloc+19>: test %eax,%eax 0x77c2c41c <msvcrt!malloc+21>: jne 0x77c2c420 <msvcrt!malloc+25> 0x77c2c41e <msvcrt!malloc+23>: pop %ebp 0x77c2c41f <msvcrt!malloc+24>: ret 0x77c2c420 <msvcrt!malloc+25>: pushl 0x77c61808 0x77c2c426 <msvcrt!malloc+31>: pushl 0x8(%ebp) 0x77c2c429 <msvcrt!malloc+34>: call 0x77c2c3d4 <msvcrt!free+441> 0x77c2c42e <msvcrt!malloc+39>: pop %ecx 0x77c2c42f <msvcrt!malloc+40>: pop %ecx 0x77c2c430 <msvcrt!malloc+41>: pop %ebp 0x77c2c431 <msvcrt!malloc+42>: ret 0x77c2c432 <msvcrt!malloc+43>: int3 0x77c2c433 <msvcrt!malloc+44>: int3 0x77c2c434 <msvcrt!malloc+45>: int3 0x77c2c435 <msvcrt!malloc+46>: int3 0x77c2c436 <msvcrt!malloc+47>: int3 End of assembler dump. Good, this is where I would expect to be, right at home inside of msvcrt. But now take a look at the first frame of our original stack trace. #0 0x003e14a0 in malloc () 0x3e14a0.. Umm, hmmm, wierd. Let's see where that leads us? (gdb) disas 0x3e14a0 Dump of assembler code for function malloc: 0x003e14a0 <malloc+0>: jmp *0x90c0609c I'd hate to say it, but there is no 0x90x0609c. That explains the segfault. Let's see what else is around 0x3e14a0... (gdb) disas 0x3e1490 Dump of assembler code for function _pei386_runtime_relocator: 0x003e1470 <_pei386_runtime_relocator+0>: mov $0x90c03034,%ecx 0x003e1475 <_pei386_runtime_relocator+5>: push %ebp 0x003e1476 <_pei386_runtime_relocator+6>: cmp $0x90c03034,%ecx 0x003e147c <_pei386_runtime_relocator+12>: mov %esp,%ebp 0x003e147e <_pei386_runtime_relocator+14>: jae 0x3e1498 <_pei386_runtime_relocator+40> 0x003e1480 <_pei386_runtime_relocator+16>: mov 0x4(%ecx),%edx 0x003e1483 <_pei386_runtime_relocator+19>: mov (%ecx),%eax 0x003e1485 <_pei386_runtime_relocator+21>: add $0x8,%ecx 0x003e1488 <_pei386_runtime_relocator+24>: add $0x90c00000,%edx 0x003e148e <_pei386_runtime_relocator+30>: add %eax,(%edx) 0x003e1490 <_pei386_runtime_relocator+32>: cmp $0x90c03034,%ecx 0x003e1496 <_pei386_runtime_relocator+38>: jb 0x3e1480 <_pei386_runtime_relocator+16> 0x003e1498 <_pei386_runtime_relocator+40>: pop %ebp 0x003e1499 <_pei386_runtime_relocator+41>: ret End of assembler dump. That looks like static libgcc to me. So is libgcc calling the wrong malloc for some reason? Why? Is this a relocation problem? Is there any way I can fix this? Is there anyone else I should be asking? I am using the dwarf2 GCC 4.2.1, but I had the same results with gcc 3.4.5 (though with less details on the crash) I was thinking that maybe shared libgcc would fix my problem, but I can't seem to link with it. When I specify -shared-libgcc it says I'm missing libgcc_s.a which I can't find anywhere. Details on my setup: $ gcc -v Using built-in specs. Target: mingw32 Configured with: ../gcc-4.2.1-2-src/configure --with-gcc --enable-libgomp --host=mingw32 --build=mingw32 --target=mingw32 --program-suffix=-dw2 --with-arch=i486 --with-tune=generic --disable-werror --prefix=/mingw --with-local-prefix=/mingw --enable-threads --disable-nls --enable-languages=c,c ++,fortran,objc,obj-c++,ada --disable-win32-registry --disable-sjlj-exceptions --enable-libstdcxx-debug --enable-cxx-flags=-fno-function-sections -fno-data-sections --enable-version-specific-runtime-libs --disable-bootstrap Thread model: win32 gcc version 4.2.1-dw2 (mingw32-2) $ld -v GNU ld version 2.17.50 20060824 MINGW runtime is a debug compiled version of mingw-runtime-3.13

1 1

BOOST_NO_IS_ABSTRACT defined for SunPRO CC?
by Sohail Somani 15 Aug '07

15 Aug '07

Hi, In the upgrade to boost 1.34.1, I noticed that the sunpro_cc.hpp config file now defines BOOST_NO_IS_ABSTRACT for the latest compiler. This affects serialization code that used to work with 1.33.1. The relevant change is here: http://svn.boost.org/trac/boost/changeset/32005 I'm wondering, why was this change made since it seems to work? There is no ticket referenced in the commit. Thanks, Sohail

2 3

[program_options] Short program options
by Christian Henning 15 Aug '07

15 Aug '07

Hi there, a while ago I was asking some questions about the short option feature. If I'm not mistaken a short option can only be one letter long. Is that correct to say? In my project I need more than this. So I started to just add the short names to the options list like I would do for all options. But in this case they would share the same variable. Like this: po::options_description settings( "" ); settings.add_options() ( "input_1" , po::value< string >( &_input ) ->default_value( "" ) , "" ) ( "i1" , po::value< string >( &_input ) ->default_value( "" ) , "" ); Both options are pointing to the same variable. For some reasons this code works only for "input_1" and not for "i1". Why is that? If I use --i1="Hallo" the _input is empty. Regards, Christian

3 3

asio's io_service uses too many file descriptors
by pete＠mu.org 15 Aug '07

15 Aug '07

I posted this under a less suitable subject line a week ago, but I got no response. I hope the above live will trigger some help. I 've been doinking around with asio for a few weeks, and I've run into an issue I can't seem to wrap my head around. I've been playing with some code that originally was meant to pound a server with a large amount of packets for benchmarking purposes. It uses threads to launch hundreds of threads per second. When I replaced the old socket code with asio, and used a single io_service with run being called within each thread, I run out of file descriptors very quickly, and if I use a single io_service within each thread it's the same thing but the performance seems worse. Needless to say, this seems like a real limitation and I'm hoping I'm just being limited by my own misunderstanding, because I'm really enjoying the portability of asio. The docs that are there seem great, but there seems to be a lot more the library can do that I am missing out on, and I think the docs seem like they are not mentioning a lot of what asio an do. Can someone point me in the right direction for launching 1-to-N threads with a single send_to and a single receive_from within each thread that doesn't take the hit I'm seeing? It seems to me, that it's obvious that the io-service design is the difference, because I don't get the issue at all when I use plain old sockets, and the OS thread limit is then the only limitation. Any help would be greatly appreciated. FYI, I've done most of my experimenting on Linux and OSX. I can send some code samples if needed, but I think the problem should be apparent if anyone else has tried to use asio with large amounts of threads. Thanks, Pete

3 4

boost serialization excessive warning messages
by Fei Liu 15 Aug '07

15 Aug '07

Hi Group, I am getting multiple warning messages like the following from boost serialization library: /usr/include/boost/archive/detail/iserializer.hpp:124: warning: unused parameter 'flags' I am pretty sure this is a common issue but I haven't found any clue through the web. Is there a way to turn off the warning through proper coding? I am using gcc on linux. Fei

5 11

[iostreams] Different character type in a filtering stream [C1]
by frederic.mayot＠sgcib.com 15 Aug '07

15 Aug '07

Hi, I'd like to create a pipeline composed of filters that have different input and output character type. For example: file -> | Source | -> char -> | F1 | -> message -> | F2 | where F1 and F2 are input filters. F1 can be kind of a parser that would cut the stream into messages. The thing is that I could always rewrite a file_source but I think it's not a good design. What would you suggest? Thanks, ____________________________ Frederic MAYOT Société Générale - Equity IT 1221 Avenue of the Americas New York, NY 10020 +1 (212) 278-5558 +1 (917) 673-1339 ************************************************************************* This message and any attachments (the "message") are confidential and intended solely for the addressees. Any unauthorised use or dissemination is prohibited. E-mails are susceptible to alteration. Neither SOCIETE GENERALE nor any of its subsidiaries or affiliates shall be liable for the message if altered, changed or falsified. *************************************************************************

1 0

Using cross-compiler to build the libraries
by Bruce Reid 15 Aug '07

15 Aug '07

I have been able to build (and link with) the libraries using the native gcc compiler on my linux-x86 platform, but have been unable to find a way to force the build process to use something like: /path/to/my/cross_compiler/for/linux-ppc/gcc Can someone please advise me in the proper way to build the libs with an absolute path to my cross compiler? Thanks very much for any help, Bruce CONFIDENTIALITY NOTICE: This email, together with any attachments, is intended only for use by Aristos Logic Corporation and the individual(s) to which it is addressed and may contain information that is privileged, confidential or exempt from disclosure. If you are not the intended recipient, you are hereby notified that any dissemination, distribution, or copying of this email, or any attachment, is strictly prohibited. If you have received this email in error, please notify Aristos Logic Corporation by sending an email to sysadm(a)aristoslogic.com and delete this email, along with any attachments, from your computer. Thank you.

2 1

boost filesystem undefined reference...
by chun ping wang 15 Aug '07

15 Aug '07

./myfile/lib/libmy.a(my.o): In function `ZN4My6My_t4initERKNS0_10Settings_tE': C:/Boost/include/boost-1_34_1/boost/filesystem/path.hpp:302: undefined reference to `boost::filesystem::detail::status_api(std::string const&, unsigned int&)' ./myfile/lib/libmy.a(my.o): In function `_tcf_0': C:/CPW/cs_classes/./myfile/include/myerror.h:186: undefined reference to `boost::filesystem::detail::get_current_path_api(std::string&)' i build boost linking to a built boost filesystem file using mingw 3.4.5 including option. -l"boost_filesystem-mgw34-1_34_1" this is line 302 of path.hpp "const external_string_type external_file_string() const { return Traits::to_external( *this, file_string() ); }" "

1 0

Searching through a vector of tuples...
by Graham Reitz 15 Aug '07

15 Aug '07

typedef boost::tuples::tuple<int,double> some_tuple; std::vector<some_tuple> vec_of_some_tuples; // ... stuff some data into the vector // ... search for a specific int in the vector of some_tuple What would be a good method, using an stl algorithm, to search through the vector above to match only the int portion of the tuple (ignoring the double)? Thanks, Graham

4 4

boost.test and independent compilation/running of tests
by Alexander Schmolck 15 Aug '07

15 Aug '07

Hi, I'm trying to figure out what the best way to use boost.test to achieve something close to TDD (test driven development) is; I should presumably also mention that I'm using qmake and not bjam as a build utility. I've managed to build and use boost.test fine (after figuring out that I needed to add -DBOOST_TEST_DYN_LINK), but what I haven't been able to achieve is to a) have several smaller test-cases/suites for TDD so that I can rapidly recompile and run a small subset of tests whilst I'm developing a specific class. b) have one big test-suite, integrating all the above, for regression testing to be run periodically (after the above subset of tests passed; on svn commit etc.) I haven't figured out how to set things up so that I can compile individual tests to .o files and then either simply build a complete regression suite executable from them or an executable from just one (or a few) of these tests; because I don't know how to use the autoregistration facilities without ending up with multiple main()s. My test files currently look something like this: //file foo_test.cpp #define BOOST_TEST_MODULE foo_test #include <boost/test/unit_test.hpp> #include "foo.h" // Test Suite BOOST_AUTO_TEST_SUITE(foo_test_suite); BOOST_AUTO_TEST_CASE(some_test_case) { // ... } BOOST_AUTO_TEST_SUITE_END(); What's the recommended way to go about this? thanks, 'as

2 3

hash_multimap serialization issue
by Lorenzo Cavallaro 15 Aug '07

15 Aug '07

Dear Boost list, I'm trying to use the boost serialization class to serialize some objects. Unfortunately, I keep running into the same issue (compilation error) that I report here below for clarity $ g++-3.4 -fPIC -O2 -g -I. -c model.cpp -o model.o /usr/include/boost/serialization/access.hpp: In static member function +`static void boost::serialization::access::serialize(Archive&, T&, unsigned +int) [with Archive = boost::archive::text_oarchive, T = +__gnu_cxx::hash_multimap<addr_t, Events*, __gnu_cxx::hash<unsigned int>, +eqaddr, std::allocator<Events*> >]': /usr/include/boost/serialization/serialization.hpp:81: instantiated from `void +boost::serialization::serialize(Archive&, T&, unsigned int) [with Archive = +boost::archive::text_oarchive, T = __gnu_cxx::hash_multimap<addr_t, Events*, +__gnu_cxx::hash<unsigned int>, eqaddr, std::allocator<Events*> >]' /usr/include/boost/serialization/serialization.hpp:140: instantiated from +`void boost::serialization::serialize_adl(Archive&, T&, unsigned int) [with +Archive = boost::archive::text_oarchive, T = __gnu_cxx::hash_multimap<addr_t, +Events*, __gnu_cxx::hash<unsigned int>, eqaddr, std::allocator<Events*> >]' /usr/include/boost/archive/detail/oserializer.hpp:148: instantiated from `void +boost::archive::detail::oserializer<Archive, +T>::save_object_data(boost::archive::detail::basic_oarchive&, const void*) +const [with Archive = boost::archive::text_oarchive, T = +__gnu_cxx::hash_multimap<addr_t, Events*, __gnu_cxx::hash<unsigned int>, +eqaddr, std::allocator<Events*> >]' model.cpp:599: instantiated from here /usr/include/boost/serialization/access.hpp:109: error: 'class +__gnu_cxx::hash_multimap<addr_t, Events*, __gnu_cxx::hash<unsigned int>, +eqaddr, std::allocator<Events*> >' has no member named 'serialize' make: *** [model.o] Error 1 I've looked for this error on Internet and I found out that a discussion on the boost mailing list dated back on 2005 (http://lists.boost.org/boost-users/2005/08/13183.php) I tried making those changes but nothing happened and I still have the reported compilation error. For the sake of clarity, here's a snippet of the code I'm trying to compile #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/serialization/base_object.hpp> #include <boost/serialization/utility.hpp> #include <boost/serialization/list.hpp> #include <boost/serialization/vector.hpp> #include <boost/serialization/hash_map.hpp> #include <ext/hash_map> using namespace std; using namespace __gnu_cxx; struct eqaddr { bool operator()(addr_t ret1, addr_t ret2) const { return ret1 == ret2; } }; typedef hash_multimap<addr_t, Events *, hash<addr_t>, eqaddr> model_t; class ModelMap { friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int file_version) { ar & map; } public: model_t map; ModelMap() { } ~ModelMap() { } }; I'm using libboost-serialization 1.33.1-10 (debian) Any idea on how to fix this? Am I doing something wrong? TIA, bye Lorenzo -- Lorenzo `Gigi Sullivan' Cavallaro <sullivan(a)security.dico.unimi.it> GPG key at http://security.dico.unimi.it/~sullivan/sullivan.asc Until I loved, life had no beauty; I did not know I lived until I had loved. (Theodor Korner) See the reality in your eyes, when the hate makes you blind. (A.H.X)

1 0

How to import a dll to python
by desai3＠cooper.edu 14 Aug '07

14 Aug '07

Hi all: I am completely new to Python and Boost.python. (I have been using it for two days) I was trying out a tutorial example that is located in the boost_1_34_1\libs\example\tutorial folder of the standard Boost distribution. After running ./Bjam target-os=cygwin toolset = gcc it created hello.dll, hello.dll.a and hello.o files in boost_1_34_1\libs\python\example\tutorial\bin\gcc-3.4.4\debug. However, when I go to python and use "import python" it gives me following error ######################################## Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: No module named hello ######################################## What am I doing wrong? I am completely new to this boost and python so simplified answers will help a lot. Thank you

2 3

any_cast on polymoprhic types?
by Gross, Steve 14 Aug '07

14 Aug '07

Is there a way to use any_cast for polymorphic types? For instance, let's say I've got a Base class and a Derived class. I want to be able to any_cast a Derived * to a Base * successfully, like so: class Base { virtual ~Base() {} }; class Derived : public Base { virtual ~Derived() {} }; Derived d; boost::any a = &d; boost::any_cast<Base*>(a); // Will NOT throw an exception Thanks! --Steve

1 0

ptr_map<int, T> where T has no default constructor because its private members are const
by e r 14 Aug '07

14 Aug '07

hi, i can build a map<int,A*>, but not a boost::ptr_map<unsigned int,A>. could someone please help? thank you, e. #include <boost/ptr_container/ptr_map.hpp> using std::map; using std::cout; using std::endl; class A{ public: A(double x_):x(x_){}; const double x; }; int main(){ map<int,A*> map_A; //cannot use map<int,A> //because A() not defined //why? because A has const members. A a(0.0); map_A[0]=new A(0.0);//fine boost::ptr_map<unsigned int,A> ptr_map_A; ptr_map_A[0]=new A(0.0);//not fine return 0; }; **** Build of configuration Debug for project testing_map **** make -k all Building file: ../main.cpp Invoking: GCC C++ Compiler g++ -I/usr/local/boost_1_34_1 -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"main.d" -MT"main.d" -o"main.o" "../main.cpp" ../main.cpp:25:3: warning: no newline at end of file ../main.cpp: In function ‘int main()’: ../main.cpp:22: error: no match for ‘operator=’ in ‘ptr_map_A.boost::ptr_map<unsigned int, A, std::less<unsigned int>, boost::heap_clone_allocator, std::allocator<std::pair<const unsigned int, void*> > >::<anonymous>.boost::ptr_map_adapter<A, std::map<unsigned int, void*, std::less<unsigned int>, std::allocator<std::pair<const unsigned int, void*> > >, boost::heap_clone_allocator>::<anonymous>.boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator>::operator[] [with T = A, VoidPtrMap = std::map<unsigned int, void*, std::less<unsigned int>, std::allocator<std::pair<const unsigned int, void*> > >, CloneAllocator = boost::heap_clone_allocator](((const unsigned int&)((const unsigned int*)(&0u)))) = (((A*)operator new(8u)), (<anonymous>->A::A(0.0), <anonymous>))’ ../header.h:4: note: candidates are: A& A::operator=(const A&) /usr/local/boost_1_34_1/boost/ptr_container/ptr_map_adapter.hpp: In member function ‘typename boost::ptr_container_detail::associative_ptr_container<boost::ptr_container_detail::map_config<T, VoidPtrMap>, CloneAllocator>::reference boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator>::insert_lookup(const typename boost::ptr_container_detail::associative_ptr_container<boost::ptr_container_detail::map_config<T, VoidPtrMap>, CloneAllocator>::key_type&) [with T = A, VoidPtrMap = std::map<unsigned int, void*, std::less<unsigned int>, std::allocator<std::pair<const unsigned int, void*> > >, CloneAllocator = boost::heap_clone_allocator]’: /usr/local/boost_1_34_1/boost/ptr_container/ptr_map_adapter.hpp:268: instantiated from ‘typename boost::ptr_container_detail::associative_ptr_container<boost::ptr_container_detail::map_config<T, VoidPtrMap>, CloneAllocator>::reference boost::ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator>::operator[](const typename boost::ptr_container_detail::associative_ptr_container<boost::ptr_container_detail::map_config<T, VoidPtrMap>, CloneAllocator>::key_type&) [with T = A, VoidPtrMap = std::map<unsigned int, void*, std::less<unsigned int>, std::allocator<std::pair<const unsigned int, void*> > >, CloneAllocator = boost::heap_clone_allocator]’ ../main.cpp:22: instantiated from here /usr/local/boost_1_34_1/boost/ptr_container/ptr_map_adapter.hpp:168: error: no matching function for call to ‘A::A()’ ../header.h:6: note: candidates are: A::A(double) ../header.h:4: note: A::A(const A&) make: *** [main.o] Error 1 make: Target `all' not remade because of errors. Build complete for project testing_map

2 1

[program_options] Short name strategy
by Larry 14 Aug '07

14 Aug '07

I didn't see anythiing in the doc but is there some compelling reason why short names for options was limited to a single character? The code fails an assert if the short name is more than one character. It just seems like an unnecessary limitation. Larry

2 1

Meaning of a library suffix
by Philippe Mondon 14 Aug '07

14 Aug '07

Hi, Can anyone tell me what means the library suffix : *sgd-*.lib My code on windows wants to link with this library and I don't understand why. Thanks, Regards, Philippe Mondon Equipe PAC/Architecture DIMC Calyon Ce message et ses pièces jointes (le "message") est destiné à l'usage exclusif de son destinataire. Si vous recevez ce message par erreur, merci d'en aviser immédiatement l'expéditeur et de le détruire ensuite. Le présent message pouvant être altéré à notre insu, CALYON Crédit Agricole CIB ne peut pas être engagé par son contenu. Tous droits réservés. This message and/or any attachments (the "message") is intended for the sole use of its addressee. If you are not the addressee, please immediately notify the sender and then destroy the message. As this message and/or any attachments may have been altered without our knowledge, its content is not legally binding on CALYON Crédit Agricole CIB. All rights reserved.

2 2

[program_options] how to link to the release version of static library
by 顾铭秋 14 Aug '07

14 Aug '07

Hi, I'm using Boost 1.34.1 with MS VC8. Release version of my project will link to the debug version of static library (libboost_program_options-vc80-mt-sgd-1_34_1.lib). This will cause some link error (symbol redefinition in debug and release version of system library). How can I link to the release version of the library(libboost_program_options-vc80-mt-s-1_34_1.lib)? Thanks! MQ Gu

1 0

Re: [Boost-users] [tests] Signals not well covered in unit tests (incontrast to exceptions)?
by Gennadiy Rozental 14 Aug '07

14 Aug '07

> "Jens Seidel" <jensseidel(a)users.sf.net> wrote in message > news:20070726151640.GA19199@imkf-pc073.imkf.tu-freiberg.de... > Hi, > > I have the following problem with a C++ project on Linux using the > Boost.test framework: Can you write simple example that show the problem? Gennadiy

2 2

boost test documentation update.
by Yann Golanski 14 Aug '07

14 Aug '07

Is there an ETA to the Boost test documentation update? At the moment, the documentation is rather poor which is a shame since the library is good. -- yann(a)kierun.org -= H+ =- www.kierun.org PGP: 009D 7287 C4A7 FD4F 1680 06E4 F751 7006 9DE2 6318

2 1

Spirit - Cannot get my actors straight
by Anders Dalvander 14 Aug '07

14 Aug '07

Hi, I'm trying to create a parser that shall create a number of derived classes based on the input, put it in a shared_ptr<Base> and push_back to a vector. Example: "Alpha" => vec.push_back(shared_ptr<Base>(new Alpha())) "Beta[1]" => vec.push_back(shared_ptr<Base>(new Beta(1))) "Gamma[2-3]" => vec.push_back(shared_ptr<Base>(new Gamma(2, 3))) "Gamma[4-End]" => vec.push_back(shared_ptr<Base>(new Gamma(4))) I've defined the actor as [push_back_a(self.vec, BasePtr(new Alpha()))], but that obviously doesn't work as BasePtr(new Alpha()) creates a temporary shared_ptr that will be destroyed by the end of the statement. How can I delay the creation of the shared_ptr, and how can I delay the new statement? Using Boost 1.34.1, MSVC++ 2005. Thanks, Anders Dalvander #include <vector> #include <boost/optional.hpp> #include <boost/shared_ptr.hpp> #include <boost/spirit.hpp> #include <boost/spirit/actor/push_back_actor.hpp> #include <boost/spirit/phoenix.hpp> using namespace boost::spirit; using namespace phoenix; class Base { public: virtual ~Base() = 0 {} }; typedef boost::shared_ptr<Base> BasePtr; class Alpha : public Base { public: Alpha() {} virtual ~Alpha() {} }; class Beta : public Base { public: explicit Beta(int var) : var(var) {} virtual ~Beta() {} private: int var; }; class Gamma : public Base { public: explicit Gamma(int var1) : var1(var1), var2() {} Gamma(int var1, int var2) : var1(var1), var2(var2) {} virtual ~Gamma() {} private: int var1; boost::optional<int> var2; }; struct my_grammar : grammar<my_grammar> { template <typename ScannerT> struct definition { typedef rule<ScannerT> rule_t; explicit definition(const my_grammar& self) { my_rule = str_p("Alpha")[push_back_a(self.vec, BasePtr(new Alpha()))] | ("Beta[" >> int_p[var(var1) = arg1] >> "]")[push_back_a(self.vec, BasePtr(new Beta(var1)))] | ("Gamma[" >> int_p[var(var1) = arg1] >> "-" >> int_p[var(var2) = arg1] >> "]")[push_back_a(self.vec, BasePtr(new Gamma(var1)))] | ("Gamma[" >> int_p[var(var1) = arg1] >> "-End]")[push_back_a(self.vec, BasePtr(new Gamma(var1)))] ; } int var1; int var2; rule_t my_rule; const rule_t& start() const { return my_rule; } }; my_grammar(std::vector<BasePtr>& vec) : vec(vec) { } std::vector<BasePtr>& vec; }; int main() { std::vector<BasePtr> vec; my_grammar g(vec); parse("Alpha", g); parse("Beta[1]", g); parse("Gamma[2-3]", g); parse("Gamma[4-End]", g); }

2 1