- Boost - lists.boost.org

Re: [boost] Boost::Serialization Combined XML- and Binary-Serialization
by Daniel Kunz 20 Jul '09

20 Jul '09

Hallo, I found my failure with xml serialization. It works now! Thanks Robert Ramey! Now I just have my problems with binary serialization. Can somebody help me with this? Best regards. Daniel Robert Ramey wrote: >Try replacing >> boost::serialization::binary_object bo = >> boost::serialization::make_binary_object(minute, >with > boost::serialization::binary_object bo = > boost::serialization::make_binary_object(& minute, >Robert Ramey >Daniel Kunz wrote: >> Hello, >> I try to write an function, which can convert data via the >> serialization interface >> XML --> class --> binary AND >> binary --> class --> XML >> I read the documentation and in the mailing lists but I could not >> finish my functions. >> >> I have 2 problems: >> 1) the xml function delivers no xml data in my testfile output >> 2) I cannot add the binary structure to the existing xml-working >> classes >> With the binary serialization I didn't find many informations, but >> that informations I found I can't use with the classes I prepared for >> xml serialization >> Is it possible to combine that 2 serializations >> >> Here is my testing code I worked with so far. The finish >coding is >> similar with that class structure. >> >> The class structure: >> >> -------------------------------------------------------- >> goal.cpp >> -------------------------------------------------------- >> #include <string> >> #include <iostream> >> >> using namespace std; >> >> #include <boost/serialization/base_object.hpp> >> #include <boost/serialization/list.hpp> >> #include <boost/serialization/is_abstract.hpp> >> >> #include <boost/archive/xml_iarchive.hpp> >> #include <boost/archive/xml_oarchive.hpp> >> #include <boost/archive/binary_iarchive.hpp> >> #include <boost/archive/binary_oarchive.hpp> >> #include <boost/serialization/binary_object.hpp> >> namespace serialization >> { >> >> class Goal >> { >> public: >> enum Scored{home=0, visitors=1}; >> Goal(){}; >> Goal(const string _name, int &_minute, bool &_shootout, Scored >> &_scored, bool &_penality); >> ~Goal(){}; >> friend ostream & operator<<(ostream &os, const Goal &_goal); >> private: >> friend class boost::serialization::access; >> template<class Archive> >> void serialize(Archive & ar, const unsigned int version) >> { >> using boost::serialization::make_nvp; >> ar & make_nvp("Name", name); >> ar & make_nvp("Minute", minute); >> ar & make_nvp("Shootout", shootout); >> ar & make_nvp("Scored", scored); >> ar & make_nvp("Penality", penality); >> >> boost::serialization::binary_object bo = >> boost::serialization::make_binary_object(minute, >> sizeof(minute)); >> ar & bo; >> } >> string name; >> int minute; >> bool shootout; >> Scored scored; >> bool penality; >> }; >> } >> >> -------------------------------------------------------- >> stadium.h >> -------------------------------------------------------- >> #include <string> >> #include <iostream> >> >> using namespace std; >> #include <boost/serialization/base_object.hpp> >> #include <boost/serialization/list.hpp> >> #include <boost/serialization/is_abstract.hpp> >> >> #include <boost/archive/xml_iarchive.hpp> >> #include <boost/archive/xml_oarchive.hpp> >> #include <boost/archive/binary_iarchive.hpp> >> #include <boost/archive/binary_oarchive.hpp> >> >> namespace serialization >> { >> >> class Stadium >> { >> private: >> friend class boost::serialization::access; >> template<class Archive> >> void serialize(Archive & ar, const unsigned int version) >> { >> using boost::serialization::make_nvp; >> ar & make_nvp("Name", name); >> ar & make_nvp("City", city); >> ar & make_nvp("Spectators", spectators); >> } >> string name; >> string city; >> int spectators; >> public: >> Stadium(){}; >> Stadium(const string _name, const string _city, int >> &_spectators); friend ostream & operator<<(ostream &os, >> Stadium &_stadium); }; >> } >> >> -------------------------------------------------------- >> match.h >> -------------------------------------------------------- >> #include <list> >> #include <time.h> >> #include <string> >> #include <iostream> >> #include <cstdio> >> >> using namespace std; >> >> #include <boost/serialization/base_object.hpp> >> #include <boost/serialization/list.hpp> >> #include <boost/serialization/is_abstract.hpp> >> >> #include <boost/archive/xml_iarchive.hpp> >> #include <boost/archive/xml_oarchive.hpp> >> #include <boost/archive/binary_iarchive.hpp> >> #include <boost/archive/binary_oarchive.hpp> >> #include <boost/serialization/serialization.hpp> >> >> #include "goal.h" >> #include "stadium.h" >> >> namespace serialization >> { >> >> class Match >> { >> private: >> friend class boost::serialization::access; >> template<class Archive> >> >> void serialize(Archive & ar, const unsigned int version) >> { >> using boost::serialization::make_nvp; >> ar & make_nvp("Home", home); >> ar & make_nvp("Visitors", visitors); >> ar & make_nvp("Kickoff", kickoff); >> ar & make_nvp("Goals", goals); >> ar & make_nvp("Stadium", stadium); >> } >> string home; >> string visitors; >> time_t kickoff; >> typedef list<Goal> lGoals; >> lGoals goals; >> Stadium stadium; >> public: >> Match(){}; >> Match(const string _home, const string _visitors, time_t >> &_kickoff, Goal *_goals, int size, Stadium &_stadium); >> Match& operator = (Match &_match); >> friend ostream & operator<<(ostream &out, Match &_match); >> }; >> } >> >> -------------------------------------------------------- >> xml.cpp >> -------------------------------------------------------- >> #include <boost/archive/xml_iarchive.hpp> >> #include <boost/archive/xml_oarchive.hpp> >> >> #include <iomanip> >> #include <iostream> >> #include <fstream> >> #include <string> >> >> #include "goal.h" >> #include "stadium.h" >> #include "match.h" >> >> #include <boost/serialization/base_object.hpp> >> #include <boost/serialization/utility.hpp> >> #include <boost/serialization/list.hpp> >> #include <boost/serialization/is_abstract.hpp> >> >> using namespace std; >> >> void save_xml(const serialization::Match &m, const string &filename) >> { >> try >> { >> ofstream ofs(filename.c_str()); >> assert(ofs.good()); >> boost::archive::xml_oarchive oa(ofs); >> oa << boost::serialization::make_nvp("Match", m); >> } >> catch(exception &e) >> { >> cout << e.what() << endl; >> } >> } >> >> void restore_xml(serialization::Match &m, const string &filename) >> { >> try >> { >> ifstream ifs(filename.c_str()); >> boost::archive::xml_iarchive ia(ifs); >> ia >> boost::serialization::make_nvp("Match", m); >> } >> catch(exception &e) >> { >> cout << e.what() << endl; >> } >> } >> >> -------------------------------------------------------- >> binary.cpp >> -------------------------------------------------------- >> void save_bin(const serialization::Match &m, const string &filename) >> { >> try >> { >> std::ofstream ofs(filename.c_str()); >> boost::archive::binary_oarchive oa(ofs); >> //oa << m; >> } >> catch(exception &e) >> { >> cout << e.what() << endl; >> } >> } >> >> void restore_bin(serialization::Match &m, const string &filename) >> { >> try >> { >> std::ifstream ifs(filename.c_str()); >> boost::archive::binary_iarchive ia(ifs); >> //ia >> m; >> } >> catch(exception &e) >> { >> cout << e.what() << endl; >> } >> } >> >> >> I hope somone can help me. I don't know what I can do to complete that >> functions. >> >> Best regards >> Daniel

2 2

RFC - MapReduce library is now available in the Vault
by Craig Henderson 19 Jul '09

19 Jul '09

I have uploaded the first public release of my MapReduce library to the Boost Vault (I don't yet have write access to the sandbox). The ZIP file is very small, 38Kb, and can be downloaded here: http://tinyurl.com/boost-mapreduce-zip More general discussion about my implementation of MapReduce and associated Distributed File System is on my blog at http://craighenderson.co.uk/blog/ The library is fully functional on Windows with MSVC8, and compiles cleanly with GCC 3.4.4 on Cygwin (but not tested). I'd appreciate comments from anyone with other platforms/compilers on whether it builds & runs. I'll get the code into the sandbox asap, and would welcome patches to support other platforms. Documentation is included in the zip and provides a tutorial and example application. A full reference document of the classes in the library is not yet included, but I'm working on it. I would very much welcome all comments on the library and suggestions on its design and style. I am keen to progress this to submit for a formal review to become a part of Boost in the near future. Many thanks -- Craig Craig Henderson <http://craighenderson.co.uk/> http://www.craighenderson.co.uk http://www.siteupdatenotification.com

1 0

[array] Custom constructr/destructor
by Kasra 18 Jul '09

18 Jul '09

Hello, I have found an interesting problem regardin using custom allocators/deallocators for an array object. Say for example you want to initialise the array to some values and on destruction you want to do something with these values. This at the memoment is not possible. The solution is to create a new class which inherits from array. template<class T, std::size_t N> class array; template<class T, std::size_t N> class my_array: public array<T,N> { my_array() { ... } ~my_array() { ... } }; Which is not an ideal solution and results in code bloat. However a defenition like bellow: template<class T, std::size_t N, class PredCtor, class PredDtor> class array; Means the same code could be used for custom operations during construction and destruction. Is there any interest in such a change? If so maybe we could propose this for the standard. Yours truly, -- Kasra

2 1

program_options easy_init
by Zachary Turner 18 Jul '09

18 Jul '09

I'm just wondering if there's a specific reason why boost::program_options::options_description_easy_init::operator() takes arguments (const char*, value_semantic, const char*) instead of (const std::string&, value_semantic, const std::string&)? Nothing major, but it's annoying when you want to pass something like str1+str2 as one of the string arguments.

2 1

Re: [boost] RFC: interest in Unicode codecs?
by Graham 18 Jul '09

18 Jul '09

Dear Phil, >Having said all that, I must say that I actually use the code that I >wrote quite rarely. I now tend to use UTF8 everywhere and treat it as >a sequence of bytes. Because of the properties of UTF8 I find it's >rare to need to identify individual code points. For example, if I'm >scanning for a matching " or ) I can just look for the next matching >byte, without worrying about where the character boundaries are. Using UTF-8 can work well if you are only targeting American and Western Europe for non-literary use. If you need to support the rest of the world you really need to move to UTF-32 due to the large number of characters and the grapheme and glyph handling [e.g. in Urdu you can type 3 characters and they are displayed as a single combined glyph, and the cursor should never be placed between them]. Even in UTF-8 things can get a bit tricky. For example, where do you break the line if you needed in the middle of: joe)jack -> joe) <br> jack joe(jack -> joe <br> (jack joe+jack -> guess which is the standard ! For programmers we don't mind too much, but when you are writing text editors this can be really important. Now think how many characters there are with special rules on whether they can be split before, after, or never split, and you start to touch on the reason for the Unicode standard and why you need character properties. Yours, Graham

5 4

[graph] Graph and AdjacencyMatrix
by Andrew Sutton 18 Jul '09

18 Jul '09

There was a bug reported (#3266) that brings up a valid problem with the BGL concept hierarchy and the edge() function. It turns out that virtually every graph defines the edge() function, but only the AdjacencyMatrix concept actually requires it as part of its interface. This means that every algorithms (e.g., Kolomogrov's Max Flow) that uses the edge() function implicitly requires graphs to model the AdjacencyMatrix concept. Since we're addressing edge-related operations, we could also take this time to clean up some of the confusion on source, target, and edge descriptors. Specifically, source() and target() are always defined and that edge descriptors - even those for undirected graphs - imply directionality. Basically, it doesn't matter if the underlying graph implementation defines source and target, the adaptation to the BGL /has to/ in order for even the most basic algorithms to work correctly. I suggest that we modify the Graph concept to define the following valid expressions. edge(u, v, g) -> pair<edge_descriptor, bool> source(e, g) -> vertex_descriptor target(e, g) -> vertex_descriptor And the following semantics: source(edge(u, v, g), g) == u target(edge(u, v, g), g) == v edge, source, target = O(E) // upper bound on an edge list. Basically this requires the edge() function to preserve the source/target ordering of the vertices in the edge that it describes. I don't believe that any graph implementations or adaptors need to be modified in order to support these changes. We can then modify the AdjacencyMatrix concept to document a refinement of the edge function, specifically that it return in O(1) time. Does anybody see any obvious problems with these changes? Andrew Sutton andrew.n.sutton(a)gmail.com

2 4

[xpressive] Performance Tuning?
by Stewart, Robert 17 Jul '09

17 Jul '09

I was experimenting with Xpressive to see how it would compare with some custom, string-based numeric input parsing. The Xpressive code is over 175X slower than the custom code. Have I done anything to make it really slow? Can it be made faster? I have included the Xpressive code and the performance testing code below for your study. Can you spot anything I've done wrong? (BTW, I tried using Spirit.Qi for this -- with Boost 1.37 -- but never could get things to compile. I gave up and decided I'd wait until I can use a newer release before I fight that fight again. :-} ) FYI: bar::numeric_cast winds up calling strtod(), strtol(), etc. It is semantically equivalent to lexical_cast. #include <boost/xpressive/xpressive_static.hpp> #include <boost/xpressive/regex_actions.hpp> namespace foo { namespace op { template <class T> struct numeric_cast { typedef T result_type; template <class Value> T operator ()(Value const & _value) const { return bar::numeric_cast<T>(_value); } }; } struct direct_impl { typedef int64_t result_type; template <class Value> int64_t operator ()(Value const & _value) const { int64_t result(bar::numeric_cast<int64_t>(_value)); result *= 160000; return result; } }; struct to_price_impl { typedef int64_t result_type; template <class Value> int64_t operator ()(Value const & _value) const { int64_t result(0); if (_value) { double const value(bar::numeric_cast<double>(_value)); result = static_cast<int64_t>( std::floor(160000.0 * value + 0.5)); } return result; } template <class Value> int64_t operator ()(Value const & _numerator, Value const & _denominator) const { unsigned const numerator(bar::numeric_cast<unsigned>(_numerator)); unsigned const denominator(bar::numeric_cast<unsigned>(_denominator)); double const fraction((160000.0 * numerator) / denominator); return static_cast<int64_t>(std::floor(fraction + 0.5)); } template <class Value> int64_t operator ()(Value const & _whole, double const _fraction) const { int const whole(bar::numeric_cast<int>(_whole)); double const value(160000.0 * whole + _fraction); return static_cast<int64_t>(std::floor(value + 0.5)); } }; int64_t parse(std::string const & _value); boost::xpressive::function<direct_impl>::type const direct = {{}}; boost::xpressive::function<to_price_impl>::type const to_price = {{}}; BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE( 1 , numeric_cast , boost::proto::default_domain , (boost::proto::tag::function) , ((op::numeric_cast)(typename)) ) } int64_t foo::parse(std::string const & _value) { using namespace boost::xpressive; if (_value.empty()) { return 0; } int64_t result; bool negative(false); sregex zero = as_xpr('0'); sregex sign = as_xpr('-') [ ref(negative) = true ] | as_xpr('+'); // ignore // ignore leading zeroes to avoid octal parsing sregex fraction = ( !zero >> (s1= +_d) >> !blank >> '/' >> !blank >> !zero >> (s2= +_d) ) [ ref(result) = to_price(s1, s2) ]; sregex real = ( *_d >> '.' >> *_d >> !((set= 'E', 'e', 'G', 'g') >> +_d) ) [ ref(result) = to_price(_) ]; // ignore leading zeroes to avoid octal parsing sregex whole_number = ( !zero >> (s1= +_d) >> +blank >> fraction ) [ ref(result) = to_price(s1, ref(result)) ]; // ignore leading zeroes to avoid octal parsing sregex integer = ( !zero >> (s1= +_d) ) [ ref(result) = direct(s1) ]; sregex price = *blank >> !sign >> (real | whole_number | fraction | integer) >> *space; smatch match; if (!regex_match(_value.begin(), _value.end(), match, price)) { throw price_parsing_failed(_value); } if (negative) { result = -result; } return result; } void test_performance() { Timer timer; std::string const input("1234.5678e10"); int64_t total(0); foo::parse(input); // prime the cache timer.start(); for (int i(0); i < 10000000; ++i) { int64_t price(foo::parse(input)); price += i; total += price; } timer.stop(); std::cout << timer.elapsed() << "s elapsed (total = " << total ')' << std::endl; } _____ Rob Stewart robert.stewart(a)sig.com Software Engineer, Core Software using std::disclaimer; Susquehanna International Group, LLP http://www.sig.com IMPORTANT: The information contained in this email and/or its attachments is confidential. If you are not the intended recipient, please notify the sender immediately by reply and immediately delete this message and all its attachments. Any review, use, reproduction, disclosure or dissemination of this message or any attachment by an unintended recipient is strictly prohibited. Neither this message nor any attachment is intended as or should be construed as an offer, solicitation or recommendation to buy or sell any security or other financial instrument. Neither the sender, his or her employer nor any of their respective affiliates makes any warranties as to the completeness or accuracy of any of the information contained herein or that this message or any of its attachments is free of viruses.

9 34

Boost filesystem get_temporary_file()
by Craig Henderson 17 Jul '09

17 Jul '09

I cannot find any function in the Boost.Filesystem library to get a temporary filename. There has been some discussion about this functionality on the lists many years ago - did anything come of this? I need a cross-platform way to do this and was hoping boost would provide it :) Thanks -- Craig Craig Henderson <http://craighenderson.co.uk/> http://www.craighenderson.co.uk http://www.siteupdatenotification.com

2 1

[smart_ptr] copyable_ptr?
by Ross Levine 17 Jul '09

17 Jul '09

I was wondering if boost has considered a smart pointer that is similar to scoped_ptr but supports deep copy semantics. This would be useful in classes which use the pimpl idiom, as a common way to program these classes is with a scoped_ptr or auto_ptr, but then a copy constructor and copy assignment operator needs to be defined. Herb Sutter worked on an implementation at http://www.gotw.ca/gotw/062.htm, so there's precedent. Is there any interest for this?

6 6

[string algo] trim() requirements to high
by Thorsten Ottosen 16 Jul '09

16 Jul '09

Hi Pavol, It seems to me that trim() and its variants that currently take a Sequence argument can be made to work iterator ranges too. For example: boost::sub_range<std::string> foo = ...; trim_left( foo ); The requirement would be trim_left: forward range trim_right: bidirectional range trim: bidirectional range Am I missing something? -Thorsten

1 0