March 2010 - Boost-users - lists.boost.org

[Serialization] Strange giant warning
by David 08 Mar '10

08 Mar '10

For a short while now I've been using boost serialization. It works perfectly... except... it keeps coming up one massive warning (that takes up ~100 lines). (see below) Whenever I get annoyed, I try to experiment and then search for answers online, but no luck. I'm probably using the library incorrectly somewhere. So I made a small program that generates the problem. Any advice on what I could be doing wrong would be appreciated. I use vc++ 2008 btw. Thanks. Code: -------------------------------------------- /* demonstration of problem. The program asks the user for a number, and then saves this number to a file. When the user returns, the number is remembered. */ #include <iostream> #include <fstream> #include <boost/serialization/shared_ptr.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> // save and load methods void save (const char * fname); bool load (const char * fname); // returns if successful // I know this is way too simple to put in a class, but bare with me class Game { public: Game () { number = 0; } void getNumberFromUser () { std::cin >> number; } int getNumber () { return number; } private: int number; friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & number; } }; typedef boost::shared_ptr< Game > Game_ptr; Game_ptr game; // entry int main () { game = Game_ptr( new Game ); // welcome std::cout << "Hello\n"; // if file exists, recall the number if (load ("save.txt")) std::cout << "You're number is " << game->getNumber() << ".\n"; // ask user for number std::cout << "Enter a number: \n"; game->getNumberFromUser (); // memorise number save ("save.txt"); // exit return 0; } void save (const char * fname) { std::ofstream ofs( fname ); boost::archive::text_oarchive oa( ofs ); // save oa << game; } bool load (const char * fname) { std::ifstream ifs( fname ); if (!ifs) return false; // file doesn't already exist boost::archive::text_iarchive ia( ifs ); // load ia >> game; // <------ Removing this line makes the warning go away return true; } Warning: -------------------------------------------- 1>main.cpp 1>d:\dev\boostpro\boost\boost_1_40\boost\serialization\extended_type_info_typeid.hpp(88) : warning C4099: 'boost::serialization::static_warning_impl<false>::STATIC_WARNING' : type name first seen using 'struct' now seen using 'class' 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\static_warning.hpp(115) : see declaration of 'boost::serialization::static_warning_impl<false>::STATIC_WARNING' 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\extended_type_info_typeid.hpp(85) : while compiling class template member function 'const boost::serialization::extended_type_info *boost::serialization::extended_type_info_typeid<T>::get_derived_extended_type_info(const T &) const' 1> with 1> [ 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\shared_ptr_helper.hpp(105) : see reference to class template instantiation 'boost::serialization::extended_type_info_typeid<T>' being compiled 1> with 1> [ 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\shared_ptr.hpp(138) : see reference to function template instantiation 'void boost::archive::detail::shared_ptr_helper::reset<Game>(boost::shared_ptr<T> &,T *)' being compiled 1> with 1> [ 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\split_free.hpp(58) : see reference to function template instantiation 'void boost::serialization::load<Archive,Game>(Archive &,boost::shared_ptr<T> &,const unsigned int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\split_free.hpp(54) : while compiling class template member function 'void boost::serialization::free_loader<Archive,T>::invoke(Archive &,T &,const unsigned int)' 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=boost::shared_ptr<Game> 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\split_free.hpp(74) : see reference to class template instantiation 'boost::serialization::free_loader<Archive,T>' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=boost::shared_ptr<Game> 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\shared_ptr.hpp(153) : see reference to function template instantiation 'void boost::serialization::split_free<Archive,boost::shared_ptr<T>>(Archive &,boost::shared_ptr<T> &,const unsigned int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\serialization\serialization.hpp(133) : see reference to function template instantiation 'void boost::serialization::serialize<Archive,Game>(Archive &,boost::shared_ptr<T> &,const unsigned int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(174) : see reference to function template instantiation 'void boost::serialization::serialize_adl<Archive,T>(Archive &,T &,const unsigned int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(161) : while compiling class template member function 'void boost::archive::detail::iserializer<Archive,T>::load_object_data(boost::archive::detail::basic_iarchive &,void *,const unsigned int) const' 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(362) : see reference to class template instantiation 'boost::archive::detail::iserializer<Archive,T>' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(351) : while compiling class template member function 'void boost::archive::detail::load_non_pointer_type<Archive,T>::load_standard::invoke(Archive &,T &)' 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(417) : see reference to class template instantiation 'boost::archive::detail::load_non_pointer_type<Archive,T>::load_standard' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(405) : while compiling class template member function 'void boost::archive::detail::load_non_pointer_type<Archive,T>::invoke(Archive &,T &)' 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\iserializer.hpp(542) : see reference to class template instantiation 'boost::archive::detail::load_non_pointer_type<Archive,T>' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\common_iarchive.hpp(61) : see reference to function template instantiation 'void boost::archive::load<Archive,T>(Archive &,T &)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\basic_text_iarchive.hpp(62) : see reference to function template instantiation 'void boost::archive::detail::common_iarchive<Archive>::load_override<T>(T &,int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\text_iarchive.hpp(66) : see reference to function template instantiation 'void boost::archive::basic_text_iarchive<Archive>::load_override<T>(T &,int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\boostpro\boost\boost_1_40\boost\archive\detail\interface_iarchive.hpp(61) : see reference to function template instantiation 'void boost::archive::text_iarchive_impl<Archive>::load_override<T>(T &,int)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ] 1> d:\dev\visual studio 2008\projects\boostserialisation\boostserialisation\main.cpp(82) : see reference to function template instantiation 'Archive &boost::archive::detail::interface_iarchive<Archive>::operator >><Game_ptr>(T &)' being compiled 1> with 1> [ 1> Archive=boost::archive::text_iarchive, 1> T=Game_ptr 1> ]

3 4

[graph][spirit] Boost.Graph and Boost.Spirit incompatible ?
by Maxime van Noppen 08 Mar '10

08 Mar '10

Hi, After my very big disappointment when I discovered that Boost.Graph and Boost.Variant where incompatible[1], now it seems that Boost.Graph and Boost.Spirit (and more precisely Qi) are incompatible... :( Minimal test case : -------- test.cc ----------- #include <boost/graph/dijkstra_shortest_paths.hpp> #include <boost/spirit/include/qi.hpp> ---------------------------- > $ g++ -c test.cc > In file included from /usr/include/boost/graph/properties.hpp:19, > from /usr/include/boost/graph/named_function_params.hpp:13, > from /usr/include/boost/graph/dijkstra_shortest_paths.hpp:20, > from inc_test.cc:1: > /usr/include/boost/property_map/property_map.hpp: In instantiation of ‘boost::property_traits<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >’: > /usr/include/boost/graph/two_bit_color_map.hpp:47: instantiated from ‘boost::two_bit_color_map<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ > /usr/include/boost/spirit/home/qi/char/char.hpp:206: instantiated from here > /usr/include/boost/property_map/property_map.hpp:31: error: no type named ‘key_type’ in ‘struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >’ > /usr/include/boost/property_map/property_map.hpp:34: error: no type named ‘category’ in ‘struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >’ > /usr/include/boost/property_map/property_map.hpp: In instantiation of ‘boost::property_traits<std::list<boost::spirit::info, std::allocator<boost::spirit::info> > >’: > /usr/include/boost/graph/two_bit_color_map.hpp:47: instantiated from ‘boost::two_bit_color_map<std::list<boost::spirit::info, std::allocator<boost::spirit::info> > >’ > /usr/include/boost/spirit/home/support/detail/what_function.hpp:35: instantiated from here > /usr/include/boost/property_map/property_map.hpp:31: error: no type named ‘key_type’ in ‘class std::list<boost::spirit::info, std::allocator<boost::spirit::info> >’ > /usr/include/boost/property_map/property_map.hpp:34: error: no type named ‘category’ in ‘class std::list<boost::spirit::info, std::allocator<boost::spirit::info> >’ I have g++ 4.4.3 on Linux amd64 and Boost 1.42.0. Maybe there should be some documentation about such incompatibilities between boost libraries. [1] http://lists.boost.org/boost-users/2010/01/55317.php -- Maxime

4 21

[Review] ITL review starts today, February 18th
by Hartmut Kaiser 08 Mar '10

08 Mar '10

Hi all, The formal review of the Interval Template Library (ITL) starts today, February 18th, 2010 and will end February 27th, 2010. ITL is being developed by Joachim Faulhaber. ------------------------------------------------ About the library: The Interval Template Library (ITL) is a library of interval containers that facilitates computations on collections of intervals and associated values. Use cases of such computations typically occur in the date and time problem domain, when collections of time intervals with associated data are analyzed, combined and aggregated. But the scope of applications for interval containers is more general and not limited to date and time problems. Interval containers allow to access and manipulate collections of intervals on an abstract level as sets and maps (of elements), but also to exploit segmental information that is given by the interval borders. Interval containers are fairly generic. They can be instantiated with discrete domain (or key) types like integral numeric types or boost::date or time types. But they also work with continuous domain types like double, rational or string. Using the latter allows to represent infinite sets and maps. The interface of the interval containers strives to be very intuitive and in line with the stl and other boost libraries. * The set theoretic operations union, difference, intersection and symmetric difference are available as operators for all interval containers and for many useful overloads between them. * There is iterator support on the level of segments and interval containers can be combined with stl containers of intervals via stl algorithms. * For discrete domain types, element iterators are available which makes interval sets and maps models of SortedAssociative Containers so they can be used with many stl algorithms. All interval containers are addable and subtractable. The addability and subtractability concept of the ITL leads to a general mechanism of aggregation on interval_maps which is called 'aggregate on overlap'. Exploiting 'aggregate on overlap' allows to compute many useful aggregation results in a simple and abstract manner. The ITL's Set and Map concepts are defined by a signature and collections of laws or axioms. Those semantical constraints have been validated using automatic law based tests. This gives the library both a well founded formal specification and an unusual thorough test base. The ITL emerged out of real world use cases and is successfully used at Cortex Software GmbH since a couple of years in the production code of various applications. On the boost developer's list it has been proposed in four previews and a review request since May 2008 and has been refactored and refined according to boost standards and suggestions from the list. The ITL is available from the boost vault: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=itl_3_2 _0.zip&directory=Containers Documentation is online available at: http://www.herold-faulhaber.de/boost_itl/doc/libs/itl/doc/html/index.html The current sources are in the sandbox: https://svn.boost.org/svn/boost/sandbox/itl/ ------------------------------------------------ Everybody on this list is invited to participate in this formal review. I hope to see your review of this library, including your vote, and I welcome your participation in the discussions on the Boost mailing list. Please always state in your review, whether you think the library should be accepted as a Boost library. Additionally, please consider giving feedback on the following general topics: - 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? Regards Hartmut Review Manager --------------- Meet me at BoostCon www.boostcon.com

5 5

Random number generation
by David Kaplan 08 Mar '10

08 Mar '10

I'm using the following code to generate a random 64 bit value: boost::mt19937 rng; boost::uniform_int<uint64_t> r(0,0xffffffffffffffff); boost::variate_generator<boost::mt19937&, boost::uniform_int<uint64_t> > gen(rng, r); uint64_t id = gen(); However it seems it's not random on each execution of the program? (rather I get the same value again). How do I randomise this properly?

3 4

how to share information about a open socket?
by pedro chaparro 08 Mar '10

08 Mar '10

Hi, based on the example http://www.boost.org/doc/libs/1_42_0/doc/html/boost_asio/tutorial/tutdaytim…, i wanna to separate the part of the code that open de connection , and the part of the code that write a string over the socket, the problem is , that i have no clear how to share the information of the socket between the both fuctions. In this code below i suppose that listen fucion must to return the socket information, but what data type must the function listen() return??? thanks so much in advance void Agent::listen() { try { printf("SERVER A STARTED UDPsk \n"); boost::asio::io_service io_service; tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 7777)); //for (;;) { tcp::socket socket(io_service); acceptor.accept(socket); } } catch (std::exception& e) { std::cerr << e.what() << std::endl; } } void Agent::write() { try { std::string message = "mymsg"; boost::system::error_code ignored_error; boost::asio::write(socket, boost::asio::buffer(message), boost::asio::transfer_all(), ignored_error); sleep(1); socket.close(); return; } } catch (std::exception& e) { std::cerr << e.what() << std::endl; } } -- Ing Pedro Alonso Chaparro Valero Ciudad Politecnica de la Innovación iTEAM - Mobile Communications Group Polytechnic University of Valencia C\ Camino de Vera S/N, Edificio 8G 46022 Valencia, Spain

3 2

[Review] The review of the ITL library ends today, March 7th
by Hartmut Kaiser 08 Mar '10

08 Mar '10

Hey all, The review of Joachim Faulhabers ITL library ends today, March 7th 2010. Please get your reviews in today or get in contact with me to agree on some offline schedule. Regards Hartmut Review Manager --------------- Meet me at BoostCon www.boostcon.com

4 4

[range] Best way to construct a std::set from a range?
by Gabriel Redner 08 Mar '10

08 Mar '10

If I have a pair of iterators, I can construct a set like so: std::set<SomeType> s(it1, it2); If instead I have a range, I can adapt it like so: std::set<SomeType> s(boost::begin(range), boost::end(range)); However, my range object is being constructed on the fly. I'd like to be able to do: std::set<SomeType> s(MakeRange(args)); But clearly this is not supported by the library. It seems I need to store the range object in a variable in order to do this, which defeats the syntax-simplifying benefits of using ranges. Can this be avoided? Are there some recommended no-overhead tricks for doing this that achieve a clean syntax? Implicit conversions? Explicit "ToSet" conversion functions? Can boost.assign be of help? (My initial reading of the assign documentation suggests not, but perhaps I'm missing something). I'm also not averse to a macro so long as it looks "language-like," but so far I haven't produced anything satisfactory. Has anyone else wrestled with this one and come out victorious? Thanks, -Gabe

6 7

[mpi] open/write to file for simple output
by alfC 07 Mar '10

07 Mar '10

Hi, I am fairly new to mpi (and boost mpi). I have an mpi program and I need to dump some intermediate and results to a simple text file. First, is there already any good (using boost.mpi or not) to open and write files (let's say from process 0) and write to them. Second, if not, I am already trying to make the code as transparent as possible: I guess the most primitive way to do this is to do something like ofstream ofs(); if(world.rank()==0) ofs.open("file"); ... if(world.rank()==0) ofs<<result<<endl; but the code is full of "if(world.rank()==0)" and worst of all there is a dangling ofs. I tried other possibilities, like making intensive use of boost::optional boost::optional<std::ofstream> optional_ofs(world.rank()==0, std::ofstream("file") ); ... if(optional_ofs) *optional_ofs<<result<<endl; //or optional_ofs? *optional_ofs<<result<<endl; and even activating exceptions for boost optional, in such a way that this makes sense: try{ *optional_ofs<<result<<endl; }catch(...){} and executes only for the process(es) where the stream is actually created. The good thing is that once the stream is created it handles its own existence, regardless of the process number chosen to write to the file. I also looked into boost.interprocess file_lock but it seems it doesn't apply to this case. The third option is more complicated (although I partially implemented it already) by encapsulating this in a class such that the following syntax makes sense for the parallel execution mpi::ofstream ofs("file", world); // class mpi::ofstream is defined somehow, only one process actually opens the file ofs<<result<<endl; //(indirectly only the first process writes to the file This is even more general because (optionally) I can make the result to be printed only once if all processes agree in the results (the value of the variable is common) or different times (or just fail) if the actaul values of result do not agree from all the processes. does this all makes any sense? or I am reinventing the wheel? Also, in my particular cluster, all the processes share the same file system, which I think it is the common case but also the origin of the dilemma. (Note that I am *not* trying to write a file in parallel, I am just trying to print common (gathered) results to a file. nor I am trying to read from a file for the moment) Any advice? Thank you, Alfredo

2 1

Graph Library Random Access Iterators?
by Theodore McCormack 06 Mar '10

06 Mar '10

Hello all, I am trying to iterate through a list of edges in the boost graph library, but i would like to advance more than one at a time or be able to use random access to an edge in the set. For example: Currently, to find the edge at index in the edge set I have to iterate through all the edges: Edge e; int count = 0; for (edge_range_t er = edges(graph); er.first != er.second; er.first++) { e = (*er.first); if (count == index) break; count++; } return e; I would like something like: Edge e; edge_range_t er = edges(graph); e = (*er[index].first); return e; Is there a way to index with iterators? Regards

3 7

[boost-users][git] gitting boost
by Andrey Torba 06 Mar '10

06 Mar '10

Hi all, I prefer git over svn. I use a git clone of boost: origin git://sodium.resophonic.com/boost It had worked perfectly until several months ago it started to return the error on 'git pull' command: fatal: The remote end hung up unexpectedly The same error occurs if i clone git://gitorious.org/boost/svn.git. I use git version 1.6.3.3. How can i git boost? Thanks -- Regards, Andrey

1 0