March 2005 - Boost - lists.boost.org

boost/operators.hpp remarks
by Sylvain Pion 08 Mar '05

08 Mar '05

Hi, I have been using boost/operators.hpp recently, and found it quite good at removing lines of code from my maintainance area :) I have some remarks about it : 1/ The mixed operators are only provided if you know the type in advance and it is fixed. For example, it is not possible for example to mix with a template family of types. E.g. let's say that My_type has to provide mixed operators with all types X<U>. This is not possible to do with the current library. Another related thing is how to express "I want My_type to mix with all integral types". Maybe there could be a version of the operators that uses enable_if and tr1::is_integral somehow, for this purpose ? Just a thought. 2/ I think it is "Euclidean Ring", not "Euclidian Ring" ("e" instead of "i"), hence the names for euclidian_ring_operators<T> and similar, are unfortunate. -- Sylvain

3 3

thread safety in boost date time
by Yitzhak Sapir 08 Mar '05

08 Mar '05

Boost date_time apparently has a thread safety problem in linux in that it calls localtime() in boost/date_time/time_clock.hpp and related functions rather than localtime_r() and related functions. This is even though BOOST_HAS_PTHREADS is defined by configure in user.hpp. Yitzhak Sapir

3 3

casp.hpp workaround and more
by Gennadiy Rozental 07 Mar '05

07 Mar '05

1. Shouldn't this header use workaround from config/suffix.hpp instead of BOOST_EXPLICIT_DEFAULT_TARGET? 2. Shouldn't this header be split by ..._cast? 3. Doesn't numeric_cast facility shouldn't be deprecated? Genandiy

4 23

RPC library
by Jarl Lindrud 07 Mar '05

07 Mar '05

Hi all, I've searched this list a bit and found a few mentions of rpc's (Remote Procedure Call), but nothing concrete. I've written a library for doing portable C++ RPC's, which can be downloaded at http://www.codeproject.com/threads/RMI_For_Cpp.asp Is there any interest in Boost for something like this, and if so in what directions do you all think it should be developed? Thanks! Jarl.

7 20

Re: [boost] Re: Logo Contest Current Tally
by JOAQUIN LOPEZ MU?Z 07 Mar '05

07 Mar '05

----- Mensaje original ----- De: David Abrahams <dave(a)boost-consulting.com> [...] > Well, now Joel and Jeff Garland have both told me by private mail that > there doesn't seem to be anything wrong with having a discussion about > what's worth voting for, and I am basically convinced. I think > certainaspects of the logo are more important than others and > should be > considered. But before I start blurting out any specifics, let's hear > from the group. Is there any reason we shouldn't talk about how to > choose? We do almost everything at boost by public consensus. Why > not this time? Well, I don't have any strong opinion about whether this poll should be kept in privacy or not, but certainly there is a difference between the contest and other activities: the former is a voting process, unlike all other decisions taken here (including reviews.) Joaquín M López Muñoz Telefónica, Investigacion y Desarrollo

1 0

Re: [boost] Re: Logo Contest Current Tally
by Iain Hanson 07 Mar '05

07 Mar '05

On Mon, 2005-03-07 at 12:48 -0500, David Abrahams wrote: > christopher diggins <cdiggins(a)videotron.ca> writes: > [snip] > Well, now Joel and Jeff Garland have both told me by private mail that > there doesn't seem to be anything wrong with having a discussion about > what's worth voting for, and I am basically convinced. I think certain > aspects of the logo are more important than others and should be > considered. But before I start blurting out any specifics, let's hear > from the group. Is there any reason we shouldn't talk about how to > choose? We do almost everything at boost by public consensus. Why > not this time? > I think it would be a good thing. If people are influenced by it will be no different than the review process. I also have no problem with the running tally. /ikh

1 0

FSM Review
by Peter Petrov 07 Mar '05

07 Mar '05

I have used and watched closely this library for more than a year, since its early versions. Initially, we needed a good modern state machine framework for a project at the company I work for. After evaluating the possibilities, we decided to take the risk and go with Andreas' FSM, despite its early-alpha state at the time. Now, one year later, that choice has proved to be correct. We have used FSM in one more project and are planning to use it in future projects too. * What is your evaluation of the documentation? How easy (or hard) it is to understand library features? What can be improved? The documentation is very adequate. I was able to quickly understand how to use the basic features of the library, and then proceed to the advanced ones. At that time I had experience with different kinds of state machines, but primarily SDL-specified. FSM's documentation was my first introduction to UML state charts, and did the job well. The tutorial is excellent. The FAQ and Rationale sections give important answers to questions which are likely to arise. There is also an extensive Reference section, which I needed very rarely. * What is your evaluation of the design? What features are supported better by alternative FSMs? What could be added (or removed) from the library? To me, the design is good and follows naturally from the objectives of the library. It imposes some restrictions, although they can be overcome if necessary (for me it has not been necessary). For example, machines don't recognize polymorphic events, therefore they cannot "forward" unknown events to another machine. This can be circumvented by using a "wrapper" event around such events, which works, but only with asynchronous machines. Another example is the way that state machines are inherited - it's not very flexible and only allows altering how a state machine reacts to an already recognized event. One cannot add support for new events, except using again the "wrapper event" trick. * The library documentation contains few not yet solved issues (name, separating the library into two parts, exception handling). What is you opinion here? The name (boost::fsm, Boost.FSM) is fine for me. Regarding separating the library into two parts, I prefer it being separated, since the Worker part is useful by itself. * What is your evaluation of the implementation? Are there parts of code too obscure or duplicating exiting Boost functionality? Can something be factored out to standalone library or among general utilities? It's as obscure as its complexity requires. At the same time it is stable and bug-free, which is proved by extensive bulk-testing in our labs. * Are there performance bottlenecks? Does the library design fit requirements of real-time systems? How is it usable for embedded systems? Is the documentation clear on performance tradeoffs? The documentation is definitely clear on performance tradeoffs, and it's up to the potential user to take an informed decision. One tradeoff is that dispatch time is linear to the number of nested states. In my experience this is not a problem, since there are rarely more than two nested states, and I have never seen more than three. A possible problem is that states are constructed using operator new(). The documentation clearly states that, and the library allows overcoming the issue by specifying a custom allocator for the state machine, as well as writing custom operator new()'s for all state classes. I personally am against the second requirement and think that it complicates things too much. Specifying a custom allocator for the state machine should be enough. (this is mentioned in the documentation, in the Rationale section under "Memory management customization") * What is your evaluation of the potential usefulness of the library? Can you compare this FSM to other implementations? The greatest distinction of code written using the FSM library is its manageability. It's very easy to write and subsequently evolve state machines and most common mistakes are caught at compilation time. When state machines are involved, using FSM is definitely a great improvement over using a primitive framework, or not using a framework at all (the notorious switch/case idiom). Especially if the library's advanced features are used. * Did you try to use the library? With what compiler? Did you have any problems? Do you have tips for better support of older compilers? What are possible portability problems? Used with MSVC++ 7.1 and GCC 3.x. Currently without problems. In the early versions there were some minor issues which Andreas has addressed quickly. Regarding older compilers, I don't think they should be supported by this library. * How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? In-depth study, as well as real-world usage. * Are you knowledgeable about the problem domain? To a good extent. I have developed two different state machine frameworks, although both of them were significantly lower level than FSM. I have also worked extensively with various kinds of state machines, mainly protocol-related and in telecom applications. * Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Yes. Definitely.

2 1

[interfaces] Hand written interfaces
by Jonathan Turkanis 07 Mar '05

07 Mar '05

Hi All, I'm working on ways to make the Boost Interfaces library easier to use. This involves making interface definitions compile faster and making them easier to read. Unfortunately, these are somewhat conflicting goals: really messy-looking interface definitions may compile much faster than simple ones. I'm working on four approaches to interface definitions; I plan to implement them all and then compare them. Right now I'm looking for feedback on number 4: 1. The current IDL, possibly slightly modified, in which an interface definition consists of a sequence of macro invocation 2. A modified IDL in which an interface definition consists of a single invocation; this increases the amount of preprocessor metaprogramming but decreases the amount of template metaprogramming 3. The pseudocode IDL, together with an IDL compiler which translates pseudocode definitions into C++ class definitions requiring virtually no metaprogramming. 4. Hand written interfaces, requiring virtually no metaprogramming. The point of allowing hand-written interfaces is to decrease compile times. There's no question that writing interfaces by handle will be the most difficult of the above four options. Still, writing interfaces by hand has to be reasonably straightforward or no one will ever do it. So here's my question. Consider the interface: interface IBar { void foo(const char*); int foo(int, int); }; Is the following definition of IBar so complex that it would be pointless to offer it as an alternative? template< typename Derived, typename Base, typename Flags > struct ibar_impl { struct type : Base { struct interface_metadata : metadata_base<Derived, Base, Flags> { const char* names = { "foo", "foo" }; typedef mpl::vector< void(const char*), int(int, int) > signatures; }; void foo(const char* name) { return invoker<interface_metadata, 1>::execute(this, name); } int foo(int n, int m) { return invoker<interface_metadata, 2>::execute(this, int, int); } }; }; typedef interface< ibar_impl<_, _, _> > IBar; Best Regards, Jonathan

4 8

RE: [boost] Re: review of proposed fsm library
by Dave Gomboc 07 Mar '05

07 Mar '05

> > Otherwise you would be able to mix both synchronous and > asynchronous > > states in one machine, which doesn't make sense. > > While tangential to my original point about naturally > recursive structures, I'll take time out to disagree here > too. It _can_ make sense to combine async and sync behaviour > in different parts of a state machine when one is modeling > electrical circuits, e.g. in certain regions of the circuit > one may know that the behaviour is sync and not want to spend > extra CPU by going through all the async motions. I will quickly add that this issue (combining async and sync fsms) will occur whenever one has prior components that one wishes to assemble together, where some are async and some are sync. Dave

1 0

Re: [boost] Re: review of proposed fsm library
by Dave Gomboc 07 Mar '05

07 Mar '05

> > The distinction made between state and state_machine, > which I > consider to be unfortunate, was not justified in > the rationale... > > There is at least one good reason - the library supports both > synchronous and asynchronous state machines, which are > essentially different beasts and are operated quite > differently. No such distinction exists for states, therefore > they shouldn't be treated the same way as state machines. However, asynchronous_state_machine is separated from both state_machine and state. Ergo, the reason must lie elsewhere. I didn't delve deeply into the library's support for asynchronicity, but I did consider it odd and amusing that at the level of hardware circuitry, asynchronous behaviour is the default, and work is done to get synchronous behaviour by adding latches and a clock, but that for fsm (and many, many other software components rather higher-level than a J-K flip-flop) the opposite was true. I do understand it, but I am not convinced that in this case it was the correct decision. Unforunately, I have to leave for work now. :-) > Otherwise you would be able to mix both synchronous and > asynchronous states in one machine, which doesn't make sense. While tangential to my original point about naturally recursive structures, I'll take time out to disagree here too. It _can_ make sense to combine async and sync behaviour in different parts of a state machine when one is modeling electrical circuits, e.g. in certain regions of the circuit one may know that the behaviour is sync and not want to spend extra CPU by going through all the async motions. Dave

1 0

Re: [boost] Re: RPC library
by Iain Hanson 07 Mar '05

07 Mar '05

On Sun, 2005-03-06 at 22:59 +0000, Jarl Lindrud wrote: > Iain Hanson <Iain.Hanson <at> videonetworks.com> writes: > To sum up then, your position is that: > > 1) CORBA is the be-all and end-all of distributed programming. > No. Its just the best that we have available. > 2) Anything not projected to need CORBA-style scaleability is just a "toy" and > not worthy of library support. > Probably. But the problem is that people build quick and dirty apps that grow like Topsy. Its the danger of this that make me against non scalable solutions. > > I guess you don't find much need for networking at all in Boost? At least not > beyond lowlevel socket API wrappers and assorted utilites that might be useful > for something like realtime socket apps. Anything beyond that can, and should, > be done with CORBA, regardless of scale and scope. > Doug Schmidt certainly tends to argue in this direction. However, given that CORBA is not ubiquitous and is not ever likely to be then there is always going to be a need for sockets. /ikh

1 0

Help need reed related to libboost_filesystem.lib
by Thota, Vimal 07 Mar '05

07 Mar '05

Dear friends, I am using the boost libraries for my project. When I am compiling the (libboost_filesystem.lib) with my project files libraries which is available in the ibs\filesystem\build\bin\libboost_filesystem.lib\vc7.1\release\runtime-l ink-dynamic , I am facing with the Linking issues which I have listed down. Are you people able to guess where I have gone wrong. Thanks, Vimal Thota Disk Manager error LNK2001: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::~dir_it(void)" (??1dir_it@filesystem@boost@@QAE@XZ) Disk Manager error LNK2001: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::dir_it(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (??0dir_it@filesystem@boost@@QAE@ABV?$basic_string@DU?$char_traits@D@std @@V?$allocator@D@2@@std@@@Z) Disk Manager error LNK2001: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::dir_it(void)" (??0dir_it@filesystem@boost@@QAE@XZ) Disk Manager error LNK2001: unresolved external symbol "public: __thiscall boost::filesystem::get<struct boost::filesystem::is_directory>::operator bool(void)const " (??B?$get@Uis_directory@filesystem@boost@@@filesystem@boost@@QBE_NXZ) Disk Manager error LNK2001: unresolved external symbol "public: class boost::filesystem::dir_it & __thiscall boost::filesystem::dir_it::operator++(void)" (??Edir_it@filesystem@boost@@QAEAAV012@XZ) Disk Manager error LNK2001: unresolved external symbol "public: class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __thiscall boost::filesystem::dir_it::operator*(void)const " (??Ddir_it@filesystem@boost@@QBE?AV?$basic_string@DU?$char_traits@D@std@ @V?$allocator@D@2@@std@@XZ) Disk Manager error LNK2001: unresolved external symbol ___argc Disk Manager error LNK2001: unresolved external symbol ___argv Disk Manager error LNK2001: unresolved external symbol __mbctype Disk Manager error LNK2001: unresolved external symbol __mbctype Disk Manager error LNK2005: "void * __cdecl operator new(unsigned int)" (??2@YAPAXI@Z) already defined in msvcprtd.lib(newop_s.obj) Disk Manager error LNK2005: "void * __cdecl operator new[](unsigned int)" (??_U@YAPAXI@Z) already defined in msvcprtd.lib(newaop_s.obj) Disk Manager error LNK2005: "void __cdecl operator delete(void *)" (??3@YAXPAX@Z) already defined in MSVCRTD.lib(MSVCR71D.dll) Disk Manager error LNK2005: "void __cdecl operator delete[](void *)" (??_V@YAXPAX@Z) already defined in MSVCRTD.lib(MSVCR71D.dll) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::~dir_it(void)" (??1dir_it@filesystem@boost@@QAE@XZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::dir_it(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (??0dir_it@filesystem@boost@@QAE@ABV?$basic_string@DU?$char_traits@D@std @@V?$allocator@D@2@@std@@@Z) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::dir_it::dir_it(void)" (??0dir_it@filesystem@boost@@QAE@XZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::get<struct boost::filesystem::ctime>::operator long const *(void)const " (??B?$get@Uctime@filesystem@boost@@@filesystem@boost@@QBEPBJXZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::get<struct boost::filesystem::is_archive>::operator bool(void)const " (??B?$get@Uis_archive@filesystem@boost@@@filesystem@boost@@QBE_NXZ) referenced in function "public: bool __thiscall DirectoryWatcher::next_archived(void)const " (?next_archived@DirectoryWatcher@@QBE_NXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::get<struct boost::filesystem::is_directory>::operator bool(void)const " (??B?$get@Uis_directory@filesystem@boost@@@filesystem@boost@@QBE_NXZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall boost::filesystem::get<struct boost::filesystem::mtime>::operator long const *(void)const " (??B?$get@Umtime@filesystem@boost@@@filesystem@boost@@QBEPBJXZ) referenced in function "public: long __thiscall DirectoryWatcher::next_age(void)const " (?next_age@DirectoryWatcher@@QBEJXZ) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall DMWorkflowInterface::~DMWorkflowInterface(void)" (??1DMWorkflowInterface@@QAE@XZ) referenced in function "public: void * __thiscall DMWorkflowInterface::`scalar deleting destructor'(unsigned int)" (??_GDMWorkflowInterface@@QAEPAXI@Z) Disk Manager error LNK2019: unresolved external symbol "public: __thiscall DMWorkflowInterface::DMWorkflowInterface(void)" (??0DMWorkflowInterface@@QAE@XZ) referenced in function "public: virtual void __thiscall DiskManagerService::MainThread(void)" (?MainThread@DiskManagerService@@UAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: bool __thiscall boost::filesystem::dir_it::operator!=(class boost::filesystem::dir_it const &)const " (??9dir_it@filesystem@boost@@QBE_NABV012@@Z) referenced in function "private: void __thiscall DiskManagerService::check_watchers(class std::map<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class DirectoryWatcher *,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const ,class DirectoryWatcher *> > > &,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (?check_watchers@DiskManagerService@@AAEXAAV?$map@V?$basic_string@DU?$ch ar_traits@D@std@@V?$allocator@D@2@@std@@PAVDirectoryWatcher@@U?$less@V?$ basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@2@V?$allocat or@U?$pair@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@ std@@PAVDirectoryWatcher@@@std@@@2@@std@@ABV?$basic_string@DU?$char_trai ts@D@std@@V?$allocator@D@2@@3@@Z) Disk Manager error LNK2019: unresolved external symbol "public: bool __thiscall boost::filesystem::dir_it::operator==(class boost::filesystem::dir_it const &)const " (??8dir_it@filesystem@boost@@QBE_NABV012@@Z) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: class boost::filesystem::dir_it & __thiscall boost::filesystem::dir_it::operator++(void)" (??Edir_it@filesystem@boost@@QAEAAV012@XZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: class boost::filesystem::dir_it & __thiscall boost::filesystem::dir_it::operator=(class boost::filesystem::dir_it const &)" (??4dir_it@filesystem@boost@@QAEAAV012@ABV012@@Z) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol "public: class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __thiscall boost::filesystem::dir_it::operator*(void)const " (??Ddir_it@filesystem@boost@@QBE?AV?$basic_string@DU?$char_traits@D@std@ @V?$allocator@D@2@@std@@XZ) referenced in function "private: void __thiscall DirectoryWatcher::find_next(void)" (?find_next@DirectoryWatcher@@AAEXXZ) Disk Manager error LNK2019: unresolved external symbol __mbctype referenced in function "protected: long __thiscall CEditView::OnFindReplaceCmd(unsigned int,long)" (?OnFindReplaceCmd@CEditView@@IAEJIJ@Z) Disk Manager fatal error LNK1120: 17 unresolved externals Disk Manager warning LNK4098: defaultlib 'MSVCRT' conflicts with use of other libs; use /NODEFAULTLIB:library This email may contain material that is confidential, privileged and/or attorney work product for the sole use of the intended recipient. Any review, reliance or distribution by others or forwarding without express permission is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.

1 0

[optional]output
by Gennadiy Rozental 07 Mar '05

07 Mar '05

Hi, Maybe it's something that I missed, but why optional doesn't define output operator something like this: template<typename T> inline std::ostream& operator<<( std::ostream& ostr, optional<T> const& v ) { if( v ) ostr << *v; return ostr; } Gennadiy

1 0

Boost Logo Contest Request for independent tally
by Joel de Guzman 07 Mar '05

07 Mar '05

Hi, Jonathan noted a minor error in the recent (initial) tally where his entry got listed twice. In the interest of fairness... I would like to request for help. If anyone is interested in doing an independent tally, I'd gladly provide him/her with access to the submitted votes. Regards, -- Joel de Guzman http://www.boost-consulting.com http://spirit.sf.net

2 2

[congif] BOOST_BEFRIEND_TEMPLATE, BOOST_PRIVATE
by Jonathan Turkanis 07 Mar '05

07 Mar '05

Hi, <boost/shared_ptr.hpp> contains the following in the public section of the class definition (reformatted): // Tasteless as this may seem, making all members public // allows member templates to work in the absence of member // template friends. (Matthew Langston) #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: template<class Y> friend class shared_ptr; template<class Y> friend class weak_ptr; #endif T * px; // contained pointer detail::shared_count pn; // reference counter This has become a pretty common technique, I believe. I certainly use it a lot, at any rate. I'd like to suggest two macros which would allow code like the above to be simplified as follows: BOOST_PRIVATE: BOOST_BEFRIEND_TEMPLATE(shared_ptr, Y, 1) BOOST_BEFRIEND_TEMPLATE(weak_ptr, Y, 1) T * px; // contained pointer detail::shared_count pn; // reference counter Here BOOST_PRIVATE would expand to "private" for compilers that support template friends and to "public" otherwise; BOOST_BEFRIEND_TEMPLATE would expand to a template friend declaration where supported, and to nothing otherwise. It might be desirable to have two macros BOOST_BEFRIEND_TEMPLATE_CLASS and BOOST_BEFRIEND_TEMPLATE_STRUCT to avoid compiler warnings. Jonathan

3 9

Logo Contest: Send In Your votes!
by Joel de Guzman 07 Mar '05

07 Mar '05

Hi Y'all, Acceptance of logo entries is officially over. I waited more than 24 hours after the March 1 deadline to account for the time zones. For my convenience, I find it best to simply collect the votes by email. For this purpose, I setup a mail account at address: boost.logo.contest(a)gmail.com where you can send your votes to. For transparency, I shared the password with the Boost Moderators, so they can check the status anytime. Please be reminded that voting shall be based on Instant Runoff Voting (http://www.fairvote.org/irv/whatis2.htm) meaning that each individual voter shall choose 5 favorites, in order of preference. Please send in your votes in this format: 1. 1st choice: Entry number (variant), Submitter 2. 2nd choice: Entry number (variant), Submitter 3. 3rd choice: Entry number (variant), Submitter 4. 4th choice: Entry number (variant), Submitter 5. 5th choice: Entry number (variant), Submitter ***where variant, designated by a letter, is optional. Example: 1. 225, John Doe 2. 336a, Jane Doe 3. 751, Apple Pie 4. 101b, Dorothy Rainbow 5. 855, Kim Possible I shall be collecting votes and progressively posting the results in the boost web site. The competition will close on March 15, 2005 and the winning entry will be announced soon thereafter. Regards, -- Joel de Guzman http://www.boost-consulting.com http://spirit.sf.net

5 12

RE: [boost] high_resolution_timer \ timer feature requests forBoost.Timer
by Brian Braatz 07 Mar '05

07 Mar '05

(sorry - mail client weirdness on the last post- I have fixed the doublespacing)(here is the mail again) ********************************************* First off- note that Timer can take a start time on the ctor: class timer { public: timer() { _start_time = std::clock(); } // postcondition: elapsed()==0 (snip) high_resolution_timer does not however: class high_resolution_timer { public: // ctor high_resolution_timer() { start_time.QuadPart = 0; frequency.QuadPart = 0; if (!QueryPerformanceFrequency(&frequency)) throw std::runtime_error("Couldn't acquire frequency"); restart(); } (snip) MY PROBLEM: I need to feed the timer the START time (or get FROM it the start time would be preferred) The reason I need this is because for logging purposes (working with the Profiler from Christopher Diggins) I need to log the start and stop times, and I need it to (for internal cross reference) be the same number for multiple purposes. MY REQUESTS: Easy request: high_resolution_timer is changed to have the same type of ctor as timer does May Start a discussion request: That something like a starttime() method is provided for both classes Medium request- That both classes do a typedef for the type returned by the starttime method i.e. instead of class high_resolution_timer { public: (snip) private: timer t; // backup in case of QueryPerformanceCounter() bug LARGE_INTEGER start_time; LARGE_INTEGER frequency; }; You have instead: class high_resolution_timer { public: (snip) typedef LARGE_INTEGER TIME_TYPE; private: timer t; // backup in case of QueryPerformanceCounter() bug TIME_TYPE start_time; TIME_TYPE frequency; }; (for both high_resolution_timer and timer) There you go, those are my requests. Now I will sit here quietly and hope there is a Santa Claus.... (grin)

3 2

RE: [boost] Re: high_resolution_timer \ timer feature requestsforBoost.Timer
by Brian Braatz 06 Mar '05

06 Mar '05

The code I am using was originally developed by Christopher Diggins. His code allows for use of boost.timer or the high_resolution_timer. I am currently using the high_resolution timer. THANK YOU for the suggestion of using the microsec_time_clock.hpp. I did not know that existed, do you know how does this compare to the high_resolution timer? I need to stick to a base release version of boost for production reasons, do you think this other timer will work inside 1.32? Thank you very much for your thoughts, I would not have noticed the microsec if you had not pointed it out to me. > -----Original Message----- > From: boost-bounces(a)lists.boost.org [mailto:boost-bounces@lists.boost.org] > On Behalf Of Caleb Epstein > Sent: Friday, March 04, 2005 8:32 PM > To: boost(a)lists.boost.org > Subject: Re: [boost] Re: high_resolution_timer \ timer feature > requestsforBoost.Timer > > On Fri, 4 Mar 2005 10:42:16 -0700, Brian Braatz <brianb(a)rmtg.com> wrote: > > > But the Profile LOG (like a trace of what happened) looks like this > > DEPTH NAME TIME > > 0 FuncA 2 Seconds > > 1 FuncB 1 Second > > > > Does that answer your question, or am I missing something? > > Just a subtle point, but the boost::timer class returns CPU time used > not elapsed wall-clock time and would return results of ~0.0 for a > function that just sleep'd for a second or two. > > If what you're looking for is a high-resolution clock, try > <boost/date_time/microsec_time_clock.hpp> (at least in the latest > CVS). If you want performance or profiling information, use > boost::timer. > > > -- > Caleb Epstein > caleb dot epstein at gmail dot com > _______________________________________________ > Unsubscribe & other changes: > http://lists.boost.org/mailman/listinfo.cgi/boost

2 1

Integrating Boost Documentation with Visual Studio IDE.
by Pavel Chikulaev 06 Mar '05

06 Mar '05

Hi all, I don't know how many of boosters use VC, but I think intergrating boost documentation with visual studio IDE will help VC developers a lot. Key feature is context help, for example pressing F1 when cursor is on "BOOST_PP_REPEAT" token will instantly open help on BOOST_PP_REPEAT instead of opening boost.org(or saved page), then documentation, then preprocessor, the reference, then scrolling a lot in left frame for PP_REPEAT. Right know I don't know how to do it, but I'll try to find the easiest way to do it. P.S. I almost have no exprerience with other IDEs, but I think it is also possible to integrate boost documentation with them too.

2 1

Wanted : Modified Boost Jamfiles for Mac OS X
by Tommy Nordgren 06 Mar '05

06 Mar '05

Could someone please mail me an archive with modified Jamfiles, that allows the Boost 1.32 libraries to be built with Mac OS X 10.3.8, on a 512 MB machine. Currently the build stalls when compiling a file called xml_parser.cpp, exhausting virtual memory. As an alternative, can someone tell me how to exclude builds that uses the Spirit Framework. "Home is not where you are born, but where your heart finds peace" - Tommy Nordgren, "The dying old crone"

4 3

FSM review
by Jeff Garland 06 Mar '05

06 Mar '05

I'll start my review with the conclusion: I recommend fsm be accepted into Boost -- thanks to Andreas for his excellent contribution. FSMs apply to a broad range of software products and the proposed library would simplify the implementation of many of them. * What is your evaluation of the documentation? How easy (or hard) it is to understand library features? What can be improved? Overall I think the documentation is good, although I think the tutorial code be improved slightly by carefully illustrating the 'boilerplate' part from where the user would add code either to a machine or to a state and the design tradeoffs that would drive one to this approach (we had some discussion of this earlier and it might be better in the FAQ then in the tutorial). * What is your evaluation of the design? What features are supported better by alternative FSMs? What could be added (or removed) from the library? Overall the library is well thought out and supports a wide range of essential features for building fsms. * What is your evaluation of the implementation? I spent a few minutes browsing the implementation. In general the code is written clearly and understandably -- even though I couldn't possibly understand the full context of the code or truly evaulate the implementation. There is also a large number of tests already written which should help with porting / regression testing. Overall the implementation appears to be up to usual boost standards. * Are there performance bottlenecks? Does the library design fit requirements of real-time systems? How is it useable for embedded systems? Is the documentation clear on performance tradeoffs? No opinion on this except that there is good documentation of the performance implications of using the library. * What is your evaluation of the potential usefulness of the library? *Can you compare this FSM to other implementations? Most other FSM implementations are code generators of one sort or another. For example: <http://smc.sourceforge.net>. Being a pure library (and a header library as well) makes the current proposal very attractive. No new tools to required to take advantage of the capabilities. * Did you try to use the library? With what compiler? Did you have any problems? Yes - gcc 3.3.1 under dev-c++. No problems. I modified the tutorial examples to try and understand what a user would need to learn to use the library. *Do you have tips for better support of older compilers? What are possible portability problems? I think Andreas should ignore older compilers. * How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? A few hours. I also looked at the library about a year ago and followed list discussions over the last couple years. * Are you knowledgeable about the problem domain? I'm quite famaliar with FSM for software design having first studied them in college over 20 years ago. I've also worked on projects that use state machine compilers. *The library documentation contains few not yet solved issues (name, separating the library into two parts, exception handling). What is you opinion here? 1. Library name -- Obviously boost::fsm is not for everyone.... I think the library name is fine. 2. Two libraries in one: The library consists of two parts that could easily be separated... I'd leave the library alone for now. More experience will show whether it makes sense to split it. 3. Exception handling support: Several people have rightly pointed out that the rationale for the exception handling support is too thin. The rationale seems good enough to me for now. A more advanced paper would be nice, but doesn't seem essential to using the library. 4. On some compilers (e.g. gcc), the asynchronous part of the library and most of the tests currently cannot be compiled with RTTI turned off. This isn't a problem in my view as RTTI is a feature of C++. While I acknowledge that there are a group of folks that want to turn it off for embedded work, I think if they are that concerned about performance they probably won't use fsm anyway. So the bottom line is I don't see that this is a problem. Jeff

2 1

[serialization] flush ?
by troy d. straszheim 06 Mar '05

06 Mar '05

Here's a use case that has been discussed before, but to which I couldn't seem to find any solid resolution the list archives: class A; some_oarchive oa; void mutate(shared_ptr<A>& aptr_) { aptr_ = shared_ptr<A>(new A); }; shared_ptr<A> aptr; for (int i=0; i<LARGE_NUMBER; i++) { mutate(aptr); oa << aptr; } The problem is that your oarchive ends up with somewhere between two and LARGE_NUMBER distinct A's in it. Usually two. Presumably the "two" is because in this simple example only A's are getting allocated and deallocated, and therefore there are often free A-sized blocks conveniently laying around for reuse. aptr gets assigned A's at two different alternating addresses. If it was just a plain A, you could turn off tracking by not serializing through a pointer. You'd then get the right number of A's in your archive. But if elsewhere you want to serialize A through a pointer you can't do that just for this call to operator<<(). Also you don't have a good way to see if A actually is serialized via pointer elsewhere or not. (My use case is one where lots of inexperienced programmers are modifying the data structures contained in A, and they will surely screw up if the rules are more complicated than "use BOOST_CLASS_EXPORT in your header file, and never use bald pointers, always use shared_ptr".) I looked through the archives a bunch and didn't come across anything conclusive. It seemed that some thought this kind of use case was pathological, but I'm not sure why. Of course, I'm not all that experienced with serialization. What I'd like to be able to do is to tell the archive, "The previous calls to operator<<() represent a 'snapshot' of the state of some group of objects, and now I want you to forget about existent objects because I am going to rearrange them all. Continue to track object types, but forget about the addresses." I realize that this creates the possiblity for memory leaks, but if the serialization is done through one toplevel call to operator<< on a shared_ptr whose pointee contains pointers to a whole universe of home-cooked pointer spaghetti, I don't see a better way to do this, and I don't see how to clearly express what I intend via the export and tracking macro mechanisms. You can't close and reopen the archive in the top loop, you get duplicate headers. The list archives mention the use case of serializing the state of some memory pool that is very likely to get reused: I think the little example above is probably the simplest case of this. So without asking for a sanity-check, I implemented basic_oarchive::flush(), and some tests. The changes to basic_oarchive and basic_oarchive_impl are very small. basic_oarchive has an internal object_set, which tracks object_ids and addresses. I add a num_flushed_objects member, and flush() clears out the set and adds the number of objects flushed to this counter. New tracked objects are assigned object_ids starting at num_flushed_objects + object_set.size(). In this way the class_id's are reused post-flush, but object id's are not. The interface is simply this: class A; some_oarchive oa; void mutate(shared_ptr<A>& aptr_) { aptr_ = shared_ptr<A>(new A); }; shared_ptr<A> aptr; for (int i=0; i<LARGE_NUMBER; i++) { mutate(aptr); oa << aptr; oa.flush(); } No modifications are required to the iarchive, but the user code of course has to be written in such a way that objects aren't leaked. though "oa << archive::endl;" would be a cute way to flush, too. Dunno. Is this unnecessary because I'm missing something obvious? At any rate the modified files and two tests are attached. All tests pass with this change... troy d. straszheim /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // test_flush_simple.cpp // // copyright (c) 2005 // troy d. straszheim <troy(a)resophonic.com> // http://www.resophonic.com // // 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) // should pass compilation and execution // test verifies that basic_oarchive::flush() "resets" all pointers to objects #include <iostream> #include <fstream> #include <cstdio> // remove #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::remove; } #endif #include <boost/archive/archive_exception.hpp> #include "test_tools.hpp" #include <boost/preprocessor/stringize.hpp> #include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST) #include <boost/serialization/base_object.hpp> #include <boost/serialization/export.hpp> struct A { unsigned i; template <class Archive> void serialize(Archive &ar, unsigned) { ar & BOOST_SERIALIZATION_NVP(i); } static std::size_t num_objects_; public: virtual ~A(){ num_objects_--; } A() { num_objects_++; } static std::size_t num_objects() { return num_objects_; } }; std::size_t A::num_objects_ = 0; const unsigned NUMOBJS = 4; void do_save(const char *testfile) { test_ostream os(testfile, TEST_STREAM_FLAGS); test_oarchive oa(os); oa.flush(); // be sure you can flush an empty archive A a; for (unsigned int i=0; i<NUMOBJS; i++) { a.i = i; oa << BOOST_SERIALIZATION_NVP(a); oa.flush(); BOOST_CHECK(A::num_objects() == 1); } // do some more flushes for the sake of thoroughness; oa.flush(); oa.flush(); oa.flush(); A* ap = &a; for (unsigned int i=0; i<NUMOBJS; i++) { ap->i = i; oa << BOOST_SERIALIZATION_NVP(ap); oa.flush(); BOOST_CHECK(A::num_objects() == 1); } oa.flush(); oa.flush(); oa.flush(); } // save exported polymorphic class void do_load(const char *testfile) { test_istream is(testfile, TEST_STREAM_FLAGS); test_iarchive ia(is); { A a; for (unsigned int i=0; i<NUMOBJS; i++) { ia >> BOOST_SERIALIZATION_NVP(a); BOOST_CHECK(a.i == i); BOOST_CHECK(A::num_objects() == 1); } } // a goes out of scope: no objects BOOST_CHECK(A::num_objects() == 0); A* ap; for (unsigned int i=0; i<NUMOBJS; i++) { ia >> BOOST_SERIALIZATION_NVP(ap); std::cout << "numobjs=" << A::num_objects() << std::endl; BOOST_CHECK(ap->i == i); BOOST_CHECK(A::num_objects() == (i+1)); // we leak 'em on purpose, we need to count em. } } int test_main( int /* argc */, char* /* argv */[] ) { const char * testfile = boost::archive::tmpnam(NULL); BOOST_REQUIRE(NULL != testfile); do_save(testfile); do_load(testfile); std::remove(testfile); return EXIT_SUCCESS; } // EOF /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // test_flush.cpp // // copyright (c) 2005 // troy d. straszheim <troy(a)resophonic.com> // http://www.resophonic.com // // 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) // should pass compilation and execution // test verifies that basic_oarchive::flush() "resets" all pointers to objects #include <iostream> #include <fstream> #include <cstdio> // remove #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::remove; } #endif #include <boost/archive/archive_exception.hpp> #include "test_tools.hpp" #include <boost/preprocessor/stringize.hpp> #include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST) #include <boost/serialization/base_object.hpp> #include <boost/serialization/export.hpp> class polymorphic_base { friend class boost::serialization::access; template<class Archive> void serialize(Archive & /* ar */, const unsigned int /* file_version */){ } static std::size_t num_objects_; public: virtual ~polymorphic_base(){ num_objects_--; } polymorphic_base() { num_objects_++; } static std::size_t num_objects() { return num_objects_; } }; std::size_t polymorphic_base::num_objects_ = 0; //BOOST_IS_ABSTRACT(polymorphic_base) class polymorphic_derived1 : public polymorphic_base { friend class boost::serialization::access; template<class Archive> void serialize(Archive &ar, const unsigned int /* file_version */){ ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base); } public: virtual ~polymorphic_derived1(){} }; BOOST_CLASS_EXPORT(polymorphic_derived1) class polymorphic_derived2 : public polymorphic_base { friend class boost::serialization::access; template<class Archive> void serialize(Archive &ar, const unsigned int /* file_version */){ ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base); } public: virtual ~polymorphic_derived2(){} }; BOOST_CLASS_EXPORT(polymorphic_derived2) // save exported polymorphic class void save_exported(const char *testfile) { test_ostream os(testfile, TEST_STREAM_FLAGS); test_oarchive oa(os); polymorphic_base *rb1 = new polymorphic_derived1; polymorphic_base *rb2a = new polymorphic_derived2; polymorphic_base *rb2b = new polymorphic_derived2; oa << BOOST_SERIALIZATION_NVP(rb1); oa << BOOST_SERIALIZATION_NVP(rb1); oa << BOOST_SERIALIZATION_NVP(rb2a); oa << BOOST_SERIALIZATION_NVP(rb2b); BOOST_CHECK(polymorphic_base::num_objects()==3); oa.flush(); oa << BOOST_SERIALIZATION_NVP(rb2b); oa << BOOST_SERIALIZATION_NVP(rb2a); oa << BOOST_SERIALIZATION_NVP(rb1); oa << BOOST_SERIALIZATION_NVP(rb1); BOOST_CHECK(polymorphic_base::num_objects()==3); oa.flush(); oa << BOOST_SERIALIZATION_NVP(rb1); oa << BOOST_SERIALIZATION_NVP(rb1); oa << BOOST_SERIALIZATION_NVP(rb2a); oa << BOOST_SERIALIZATION_NVP(rb2b); BOOST_CHECK(polymorphic_base::num_objects()==3); oa.flush(); delete rb1; delete rb2a; delete rb2b; BOOST_CHECK(polymorphic_base::num_objects()==0); } #define RETRIEVE_AND_CHECK(ARCHIVE, PTR, TYPE, N) \ ARCHIVE >> BOOST_SERIALIZATION_NVP(PTR); \ BOOST_CHECK_MESSAGE( \ boost::serialization::type_info_implementation<TYPE> \ ::type::get_instance() \ == boost::serialization::type_info_implementation<polymorphic_base> \ ::type::get_derived_extended_type_info(*PTR), \ "restored pointer " BOOST_PP_STRINGIZE(PTR) " not of correct type" ); \ BOOST_CHECK(polymorphic_base::num_objects()==N); // save exported polymorphic class void load_exported(const char *testfile) { test_istream is(testfile, TEST_STREAM_FLAGS); test_iarchive ia(is); polymorphic_base *rb1a = NULL, *rb1b = NULL; polymorphic_base *rb2a = NULL, *rb2b = NULL; RETRIEVE_AND_CHECK(ia, rb1a, polymorphic_derived1, 1); RETRIEVE_AND_CHECK(ia, rb1b, polymorphic_derived1, 1); RETRIEVE_AND_CHECK(ia, rb2a, polymorphic_derived2, 2); RETRIEVE_AND_CHECK(ia, rb2b, polymorphic_derived2, 3); RETRIEVE_AND_CHECK(ia, rb2b, polymorphic_derived2, 4); RETRIEVE_AND_CHECK(ia, rb2a, polymorphic_derived2, 5); RETRIEVE_AND_CHECK(ia, rb1a, polymorphic_derived1, 6); RETRIEVE_AND_CHECK(ia, rb1b, polymorphic_derived1, 6); RETRIEVE_AND_CHECK(ia, rb1a, polymorphic_derived1, 7); RETRIEVE_AND_CHECK(ia, rb1b, polymorphic_derived1, 7); RETRIEVE_AND_CHECK(ia, rb2a, polymorphic_derived2, 8); RETRIEVE_AND_CHECK(ia, rb2b, polymorphic_derived2, 9); } int test_main( int /* argc */, char* /* argv */[] ) { const char * testfile = boost::archive::tmpnam(NULL); BOOST_REQUIRE(NULL != testfile); save_exported(testfile); load_exported(testfile); std::remove(testfile); return EXIT_SUCCESS; } // EOF /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_oarchive.cpp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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. #include <boost/config.hpp> // msvc 6.0 needs this for warning suppression #include <cassert> #include <set> #include <boost/limits.hpp> #include <boost/state_saver.hpp> #include <boost/throw_exception.hpp> // including this here to work around an ICC in intel 7.0 // normally this would be part of basic_oarchive.hpp below. #define BOOST_ARCHIVE #include <boost/archive/basic_archive.hpp> #include <boost/archive/detail/basic_oserializer.hpp> #include <boost/archive/detail/basic_pointer_oserializer.hpp> #include <boost/archive/detail/basic_oarchive.hpp> #include <boost/archive/archive_exception.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4251 4231 4660 4275) #endif using namespace boost::serialization; namespace boost { namespace serialization { class extended_type_info; } namespace archive { namespace detail { class basic_oserializer; class basic_pointer_oserializer; class basic_oarchive_impl { friend class basic_oarchive; ////////////////////////////////////////////////////////////////////// // information about each serialized object saved // keyed on address, class_id struct aobject { const void * address; class_id_type class_id; object_id_type object_id; bool operator<(const aobject &rhs) const { assert(NULL != address); assert(NULL != rhs.address); if( address < rhs.address ) return true; if( address > rhs.address ) return false; return class_id < rhs.class_id; } aobject & operator=(const aobject & rhs) { address = rhs.address; class_id = rhs.class_id; object_id = rhs.object_id; return *this; } aobject( const void *a, class_id_type class_id_, object_id_type object_id_ ) : address(a), class_id(class_id_), object_id(object_id_) {} aobject() : address(NULL){} }; // keyed on class_id, address typedef std::set<aobject> object_set_type; object_set_type object_set; std::size_t num_flushed_objects; ////////////////////////////////////////////////////////////////////// // information about each serialized class saved // keyed on type_info struct cobject_type { const basic_oserializer * bos_ptr; const class_id_type class_id; bool initialized; cobject_type( std::size_t class_id_, const basic_oserializer & bos_ ) : bos_ptr(& bos_), class_id(class_id_), initialized(false) {} cobject_type(const basic_oserializer & bos_) : bos_ptr(& bos_) {} cobject_type( const cobject_type & rhs ) : bos_ptr(rhs.bos_ptr), class_id(rhs.class_id), initialized(rhs.initialized) {} // the following cannot be defined because of the const // member. This will generate a link error if an attempt // is made to assign. This should never be necessary // use this only for lookup argument cobject_type & operator=(const cobject_type &rhs); bool operator<(const cobject_type &rhs) const { return *bos_ptr < *(rhs.bos_ptr); } }; // keyed on type_info typedef std::set<cobject_type> cobject_info_set_type; cobject_info_set_type cobject_info_set; // list of objects initially stored as pointers - used to detect errors // keyed on object id std::set<object_id_type> stored_pointers; // address of the most recent object serialized as a poiner // whose data itself is now pending serialization const void * pending_object; const basic_oserializer * pending_bos; basic_oarchive_impl() : num_flushed_objects(0), pending_object(NULL), pending_bos(NULL) {} const cobject_type & find(const basic_oserializer & bos); const basic_oserializer * find(const serialization::extended_type_info &ti) const; public: const cobject_type & register_type(const basic_oserializer & bos); void save_object( basic_oarchive & ar, const void *t, const basic_oserializer & bos ); void save_pointer( basic_oarchive & ar, const void * t, const basic_pointer_oserializer * bpos ); void flush(); }; ////////////////////////////////////////////////////////////////////// // implementation of basic_oarchive implementation functions // given a type_info - find its bos // return NULL if not found inline const basic_oserializer * basic_oarchive_impl::find(const serialization::extended_type_info & ti) const { class bosarg : public basic_oserializer { bool class_info() const { assert(false); return false; } // returns true if objects should be tracked bool tracking() const { assert(false); return false; } // returns class version unsigned int version() const { assert(false); return 0; } // returns true if this class is polymorphic bool is_polymorphic() const{ assert(false); return false; } void save_object_data( basic_oarchive & ar, const void * x ) const { assert(false); } public: bosarg(const serialization::extended_type_info & type_) : boost::archive::detail::basic_oserializer(type_) {} }; bosarg bos(ti); cobject_info_set_type::const_iterator cit = cobject_info_set.find(cobject_type(bos)); // it should already have been "registered" - see below if(cit == cobject_info_set.end()){ // if an entry is not found in the table it is because a pointer // of a derived class has been serialized through its base class // but the derived class hasn't been "registered" return NULL; } // return pointer to the real class return cit->bos_ptr; } inline const basic_oarchive_impl::cobject_type & basic_oarchive_impl::find(const basic_oserializer & bos) { std::pair<cobject_info_set_type::iterator, bool> cresult = cobject_info_set.insert(cobject_type(cobject_info_set.size(), bos)); return *(cresult.first); } inline const basic_oarchive_impl::cobject_type & basic_oarchive_impl::register_type( const basic_oserializer & bos ){ cobject_type co(cobject_info_set.size(), bos); std::pair<cobject_info_set_type::const_iterator, bool> result = cobject_info_set.insert(co); return *(result.first); } inline void basic_oarchive_impl::save_object( basic_oarchive & ar, const void *t, const basic_oserializer & bos ){ // if its been serialized through a pointer and the preamble's been done if(t == pending_object && pending_bos == & bos){ // just save the object data ar.end_preamble(); (bos.save_object_data)(ar, t); return; } // get class information for this object const cobject_type & co = register_type(bos); if(bos.class_info()){ if( ! co.initialized){ ar.vsave(class_id_optional_type(co.class_id)); ar.vsave(tracking_type(bos.tracking())); ar.vsave(version_type(bos.version())); (const_cast<cobject_type &>(co)).initialized = true; } } // we're not tracking this type of object if(! bos.tracking()){ // just windup the preamble - no object id to write ar.end_preamble(); // and save the data (bos.save_object_data)(ar, t); return; } // look for an existing object id object_id_type oid(object_set.size() + num_flushed_objects); // lookup to see if this object has already been written to the archive basic_oarchive_impl::aobject ao(t, co.class_id, oid); std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool> aresult = object_set.insert(ao); oid = aresult.first->object_id; // if its a new object if(aresult.second){ // write out the object id ar.vsave(oid); ar.end_preamble(); // and data (bos.save_object_data)(ar, t); return; } // check that it wasn't originally stored through a pointer if(stored_pointers.end() != stored_pointers.find(oid)){ // this has to be a user error. loading such an archive // would create duplicate objects boost::throw_exception( archive_exception(archive_exception::pointer_conflict) ); } // just save the object id ar.vsave(object_reference_type(oid)); ar.end_preamble(); return; } // save a pointer to an object instance inline void basic_oarchive_impl::save_pointer( basic_oarchive & ar, const void * t, const basic_pointer_oserializer * bpos_ptr ){ const basic_oserializer & bos = bpos_ptr->get_basic_serializer(); std::size_t original_count = cobject_info_set.size(); const cobject_type & co = register_type(bos); if(! co.initialized){ ar.vsave(co.class_id); // if its a previously unregistered class if((cobject_info_set.size() > original_count)){ if(bos.is_polymorphic()){ const serialization::extended_type_info *eti = & bos.type; const char * key = NULL; if(NULL != eti) key = eti->key; if(NULL != key){ // the following is required by IBM C++ compiler which // makes a copy when passing a non-const to a const. This // is permitted by the standard but rarely seen in practice const class_name_type cn(key); // write out the external class identifier ar.vsave(cn); } else // without an external class name // we won't be able to de-serialize it so bail now boost::throw_exception( archive_exception(archive_exception::unregistered_class) ); } } if(bos.class_info()){ ar.vsave(tracking_type(bos.tracking())); ar.vsave(version_type(bos.version())); } (const_cast<cobject_type &>(co)).initialized = true; } else{ ar.vsave(class_id_reference_type(co.class_id)); } // if we're not tracking if(! bos.tracking()){ // just save the data itself ar.end_preamble(); state_saver<const void *> x(pending_object); state_saver<const basic_oserializer *> y(pending_bos); pending_object = t; pending_bos = & bpos_ptr->get_basic_serializer(); bpos_ptr->save_object_ptr(ar, t); return; } object_id_type oid(object_set.size() + num_flushed_objects); // lookup to see if this object has already been written to the archive basic_oarchive_impl::aobject ao(t, co.class_id, oid); std::pair<basic_oarchive_impl::object_set_type::const_iterator, bool> aresult = object_set.insert(ao); oid = aresult.first->object_id; // if the saved object already exists if(! aresult.second){ // append the object id to he preamble ar.vsave(object_reference_type(oid)); // and windup. ar.end_preamble(); return; } // append id of this object to preamble ar.vsave(oid); ar.end_preamble(); // and save the object itself state_saver<const void *> x(pending_object); state_saver<const basic_oserializer *> y(pending_bos); pending_object = t; pending_bos = & bpos_ptr->get_basic_serializer(); bpos_ptr->save_object_ptr(ar, t); // add to the set of object initially stored through pointers stored_pointers.insert(oid); } // replaces addresses of objects in the object_set with NULL so that // future objects will be duplicated, but object_id's will be // preserved. inline void basic_oarchive_impl::flush() { num_flushed_objects += object_set.size(); object_set.clear(); } ////////////////////////////////////////////////////////////////////// // implementation of basic_oarchive functions BOOST_DECL_ARCHIVE basic_oarchive::basic_oarchive() : pimpl(new basic_oarchive_impl) {} BOOST_DECL_ARCHIVE basic_oarchive::~basic_oarchive() { delete pimpl; } void BOOST_DECL_ARCHIVE basic_oarchive::save_object( const void *x, const basic_oserializer & bos ){ pimpl->save_object(*this, x, bos); } void BOOST_DECL_ARCHIVE basic_oarchive::save_pointer( const void * t, const basic_pointer_oserializer * bpos_ptr ){ pimpl->save_pointer(*this, t, bpos_ptr); } void BOOST_DECL_ARCHIVE basic_oarchive::register_basic_serializer(const basic_oserializer & bos){ pimpl->register_type(bos); } unsigned int BOOST_DECL_ARCHIVE basic_oarchive::library_version() const{ return ARCHIVE_VERSION(); } void BOOST_DECL_ARCHIVE basic_oarchive::end_preamble(){ } void BOOST_DECL_ARCHIVE basic_oarchive::flush(){ pimpl->flush(); } } // namespace detail } // namespace archive } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP #define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_oarchive.hpp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // 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. #include <boost/config.hpp> #include <boost/detail/workaround.hpp> // can't use this - much as I'd like to as borland doesn't support it // #include <boost/scoped_ptr.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/serialization/tracking.hpp> #include <boost/archive/detail/abi_prefix.hpp> // must be the last header namespace boost { namespace archive { namespace detail { class BOOST_DECL_ARCHIVE basic_oarchive_impl; class BOOST_DECL_ARCHIVE basic_oserializer; class BOOST_DECL_ARCHIVE basic_pointer_oserializer; ////////////////////////////////////////////////////////////////////// // class basic_oarchive - write serialized objects to an output stream class BOOST_DECL_ARCHIVE basic_oarchive { friend class basic_oarchive_impl; // hide implementation of this class to minimize header conclusion // in client code. note: borland can't use scoped_ptr //boost::scoped_ptr<basic_oarchive_impl> pimpl; basic_oarchive_impl * pimpl; // overload these to bracket object attributes. Used to implement // xml archives virtual void vsave(const version_type t) = 0; virtual void vsave(const object_id_type t) = 0; virtual void vsave(const object_reference_type t) = 0; virtual void vsave(const class_id_type t) = 0; virtual void vsave(const class_id_optional_type t) = 0; virtual void vsave(const class_id_reference_type t) = 0; virtual void vsave(const class_name_type & t) = 0; virtual void vsave(const tracking_type t) = 0; protected: basic_oarchive(); virtual ~basic_oarchive(); public: unsigned int library_version() const; void save_object( const void *x, const basic_oserializer & bos ); void save_pointer( const void * t, const basic_pointer_oserializer * bpos_ptr ); void register_basic_serializer(const basic_oserializer & bos); void save_null_pointer(){ vsave(NULL_POINTER_TAG); } void end_preamble(); // default implementation does nothing void flush(); }; } // namespace detail } // namespace archive } // namespace boost // required by smart_cast for compilers not implementing // partial template specialization BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION( boost::archive::detail::basic_oarchive ) #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP

2 1

[Boost-bugs] [ boost-Bugs-1157766 ] build process still hangs on xml_grammar.cpp
by SourceForge.net 06 Mar '05

06 Mar '05

Bugs item #1157766, was opened at 2005-03-06 15:28 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1157766&group_… Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Sebastian (pinguin751) Assigned to: Nobody/Anonymous (nobody) Summary: build process still hangs on xml_grammar.cpp Initial Comment: as suggested in this thread: http://lists.boost.org/MailArchives/boost/msg76792.php the build process still hangs on MacOSX when building xml_grammar.cpp (boost v1.32). the system has very high load, gcc fetches more and more memory til the system is constantly swapping ... with this fix: <darwin><release><inlining>off added to build of "serialisation" and "wserialisation" the problem could be solved (as already suggested in the mail listed above) also interesting could be this: http://lists.boost.org/MailArchives/boost/msg77573.php pls include a/the fix it into the src base thx regards, seb ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1157766&group_… ------------------------------------------------------- SF email is sponsored by - The IT Product Guide Read honest & candid reviews on hundreds of IT Products from real users. Discover which products truly live up to the hype. Start reading now. http://ads.osdn.com/?ad_id=6595&alloc_id=14396&op=click _______________________________________________ Boost-bugs mailing list Boost-bugs(a)lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/boost-bugs

1 0

[somewhat OT] BGL-based graph library
by Maxim Khesin 06 Mar '05

06 Mar '05

Hello Folks, I recently started working on a graph-algorithms library in Python. What makes this one different from the other couple of libs that are available is a heavy influence from the C++ Boost Graph Library. This is a sort of an exploration in Concept in Python without loosing the Pythonness :). There is no official code release so far, but I have been blogging ideas and code snippets here: http://pythonzweb.blogspot.com/. I already invited Jeremy Siek of BGL fame to comment, and any other comments from boost/BGL community would be most welcome (you can leave them right on the blog). thanks, max.

4 5

Unhackable Wiki
by David Abrahams 06 Mar '05

06 Mar '05

I don't see any reason our Wiki should be so vulnerable, and before we make it official I would insist that we fix that. The Boost list never gets spammed, and moderators don't even seem to have to reject any spammers. All we need to do is use the same approval and posting process for the Wiki. Is something wrong with that? -- Dave Abrahams Boost Consulting www.boost-consulting.com

4 6