- Boost - lists.boost.org

alternative stringstream class
by Samuel Krempp 25 Apr '04

25 Apr '04

I meant to mention this for a while : I've written an alternative stringstream class implementation as part of boost::format, with 2 motivations : a. make boost::format compile on platforms that don't provide std::stringstream (gcc-2.95) b. allow more efficient use of stringstream in the context of boost::format (by adding copy-less access to the stringstream's buffer, and allowing reuse of the buffer) Now it's been there working hand in hand with boost::format for a while, compiling ok on mostly all platforms, but I dont know what to do about this class, if I should leave it there undocumented and unmentionned, or document it, or make it a mini-library, or a detail or whatever. IMO this class might interest some users, as it is more flexible than std::stringstream (allowing more efficient uses in some situations), while it includes the original stringstream's interface, keeps its overall design, and ease-of-use. It lies in boost/format/alt_stringstream.hpp (and _impl.hpp) it depends on the rest of boost::format only due to workaround settings (mainly required by gcc-2.95) alt_stringstream provides the features of std::stringstream, plus : void clear_buffer(); // calls seekpos // 0-copy access : Ch * begin() const std::streamsize size() const std::streamsize cur_size() const // copy buffer to string : string_type cur_str() const // [pbase, pptr[ This cur_str() function differ from the std::stringstream str() function, which returns a copy of [pbase, epptr[, thus unaffected by calls to seekpos, actually preventing buffer-reuse. (alt_stringstream defines functions cur_str() and str(), so it can have the same behaviour as std::stringstream if used with str() ) So, what should I do with this class ? -- Samuel

1 0

Re: [boost] [multi_index] composite keys: request for advice
by JOAQUIN LOPEZ MU?Z 25 Apr '04

25 Apr '04

----- Mensaje original ----- [...] > > composite_key</* as before*> ck; > > ck(record(1,2,3))<=make_tuple(1,2); // yields true > > make_tuple(1,2)<=ck(record(1,2,3)); // yields true > > > > So far, this is all IMHO perfectly consistent, > > but the following design decision is not > > obvious to me: given the previous, what should > > be the result of > > > > ck(record(1,2,3))==make_tuple(1,2); // true or false? > > > > As these two objects are neither greater than the > > other, at least they are *equivalent*, but maybe > > allowing operator== to return true is too much. > > It sounds to me like you have a partial ordering or a strict weak > ordering, but not a total ordering. > http://www.sgi.com/tech/stl/StrictWeakOrdering.html > That is, these two objects: > ck(record(1,2,3)) make_tuple(1,2) > are in the same equivalence class, but they are not equal. My > hunch is > that if you call these two object "k" and "t" (key and tuple), > then you > should have > k < t false > t < k false > t == k does not compile > That's just my quick hunch based on what I've quoted above; I haven't > considered what consequences it has for the library, but that's my > intuitive notion of how tuples as "partial keys" ought to work. > I guess I agree with you, but I wanted to bring this in to the list to gather some opinions. Following your approach, what should we do with k <= t t <= k The options are: a. they hold true b. they do not compile I don't have any strong argument in favor of any option. Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

2 1

Re: [multi_index] composite keys: request for advice
by Dave Gomboc 25 Apr '04

25 Apr '04

[reformatted] > // yields true > composite_key</* as before*> ck; ck(record(1,2,3))<=make_tuple(1,2); > > // yields true > make_tuple(1,2)<=ck(record(1,2,3)); > > So far, this is all IMHO perfectly consistent, > but the following design decision is not > obvious to me: given the previous, what should > be the result of > > ck(record(1,2,3))==make_tuple(1,2); // true or false? > > As these two objects are neither greater than the > other, at least they are *equivalent*, but maybe > allowing operator== to return true is too much. operator== should return false here. The operands are equivalent, but not equal. Dave

1 0

Re: [boost] [multi_index] composite keys: request for advice
by JOAQUIN LOPEZ MU?Z 25 Apr '04

25 Apr '04

----- Mensaje original ----- De: Jeremy Maitin-Shepard <jbms(a)attbi.com> Fecha: Sábado, Abril 24, 2004 11:13 pm Asunto: Re: [boost] [multi_index] composite keys: request for advice > Joaquin M Lopez Munoz <joaquin(a)tid.es> writes: > > > [snip: composite key system] > > > composite_key</* as before*> ck; > > ck(record(1,2,3))<=make_tuple(1,2); // yields true > > This is not lexicographical order. According to lexicographical > ordering: > > (1, 2) < (1, 2, 3) > I did not claim that composite_key results and tuples are ordered lexicographically. What I said is that, given that a composite_key induces a lexicographical order on the elements of the multi_index_container it is used in, this can be taken advantage of to perform searches where only the first keys are given. For this to work, (1, 2) must be equivalent to (1,2,3) (meaning that !((1, 2)<(1,2,3)) and !((1,2,3)<(1,2)). I don't think there's any flaw with this approach, my doubt is about whether the fact that ck(record(1,2,3))<=make_tuple(1,2) and make_tuple(1,2)<=ck(record(1,2,3)) is reason enough to also make ck(record(1,2,3))==make_tuple(1,2) hold true. Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

1 0

max elapsed time of boost::timer
by Toon Knapen 24 Apr '04

24 Apr '04

The documentation of boost::timer states that 'The maximum measurable elapsed time may be as low as 596.5 hours (or even less) ...'. Well on many 32bit platforms this would probably even be about 71 hours. Apparantly POSIX requires CLOCKS_PER_SEC to be 10e6, so if clock_t is 32 bit, the maximum of ( clock() / CLOCKS_PER_SEC ) is 4294 seconds. Because accuracy for clock() is generally about 1 sec, using clock() is not very usefull for doing timings of short (in time) events. Even more, for short events, the boost::timer might also influence the timing too much. So clock() is generally interesting for longer timings (from 10 sec onwards). But for long events the clock_t wraps around too fast (as mentioned above). And if you're unlucky that you _start_time = clock() is or a bit smaller than std::numeric_limits< clock_t >::max() (thus near the wrap-around point), directly afterwards the expression 'clock() - start' will result in a negative value. So I would like to suggest for boost::timer to use std::time_t and use std::time(NULL) instead of clock() and use std::difftime to calculate the elapsed time. toon

4 4

A question to preprocessor gurus
by Arkadiy Vertleyb 24 Apr '04

24 Apr '04

Hi all, The MS preprocessor has the __COUNTER__ extension that expands to the next integer every time when used. Can something like this be achieved in a portable manner, maybe with the help of Boost.Preprocessor library? Thanks, Arkadiy

4 7

[circular buffer] Status of Circular Buffer lib
by Jeff Garland 24 Apr '04

24 Apr '04

I'm looking at using circular buffer on a project. With only minor adaptation it does exactly what I need. I know it has been accepted, but isn't yet in CVS. So I have a few questions: 1) Is 3.6 from the files section the latest version? 2) Any showstopper bugs I should be aware of? 3) I'm assuming it works with VC7.1 and gcc 3.x? 4) Looks like my interface needs will be pretty basic: push_back, erase, clear. I assuming review changes won't impact these, correct? 5) Any reason it is NOT ready for prime time? Thx for the great submission! Jeff

2 2

[Boost-bugs] [ boost-Bugs-940941 ] failure in boost jam unit tests on cygwin
by SourceForge.net 23 Apr '04

23 Apr '04

Bugs item #940941, was opened at 2004-04-23 12:45 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=940941&group_i… Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Kannan Goundan (cakoose) Assigned to: Nobody/Anonymous (nobody) Summary: failure in boost jam unit tests on cygwin Initial Comment: Boost Jam Version 3.1.9 The unit tests seem to assume that the "/cygdrive" mount exists. I had changed mine to "/drive" and when I tried to build, I got an assertion failure: assertion "self->size < self->capacity" failed: file "strings.c", line 16 self->size == -165761813 self->capacity == 64 backtrace: assert_invariants (strings.c:15) string_free (strings.c:44) var_expand (expand.c:410) var_expand_unit_test (expand.c:696) run_unit_tets (jam.c:197) main (jam.c:299) Even if it's not worth it to accomodate non-standard Cygwin setups such as mine, I wouldn't expect the assertion failure to occur in strings.c. I think this can be reproduced by changing the "/cygdrive/c/foo/bar" string constants to invalid paths (in expand.c on lines 682 and 702) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=940941&group_i… ------------------------------------------------------- This SF.net email is sponsored by: The Robotic Monkeys at ThinkGeek For a limited time only, get FREE Ground shipping on all orders of $35 or more. Hurry up and shop folks, this offer expires April 30th! http://www.thinkgeek.com/freeshipping/?cpg=12297 _______________________________________________ Boost-bugs mailing list Boost-bugs(a)lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/boost-bugs

1 0

gcc34: undefined reference to `__gcov_init'
by Neal D. Becker 23 Apr '04

23 Apr '04

Any clues? I am trying to rebuild an app that worked with boost_1_31_0 and gcc3.3, now with gcc3.4. I completely rebuilt boost_1_31_0 libs using: PYTHON_ROOT=/usr PYTHON_VERSION=2.3 bjam -sTOOLS=gcc -sGXX=g++34 -sGCC=gcc34 PYTHON_ROOT=/usr PYTHON_VERSION=2.3 bjam -sTOOLS=gcc -sGXX=g++34 -sGCC=gcc34 stage Then I clean out all objects from my build, and rebuilt with g++34, but I got this error: g++34 -Wl,-rpath,/usr/local/src/boost_1_31_0.gcc34/stage/lib,-rpath,./ -o Test2 Test2.o -L/usr/local/src/boost_1_31_0.gcc34/stage/lib -L. -lshannon -lboost_program_options-gcc -lrfftw -lfftw Test2.o(.text+0x7d6e): In function `global constructors keyed to _Z21DesignImpulseResponseRKN10__gnu_norm6vectorISt7complexIdESaIS2_EEE_GCOV': /home/nbecker/shannon/TestAloha/Test2.cc:360: undefined reference to `__gcov_init'

2 1

[serialization] and shared_ptr
by Jeff Flinn 23 Apr '04

23 Apr '04

The following code produces and access violation when loading the NULL shared_ptr. Is this an issue of not having registered the type pointed to? What would I need to do to appropriately handle this situation? #include <boost/serialization/shared_ptr.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> #include <boost/archive/xml_oarchive.hpp> #include <boost/archive/xml_iarchive.hpp> #include <fstream> typedef std::string tName; class PointedToClass { tName mName; friend class boost::serialization::access; template< class Archive > void serialize( Archive &ar, unsigned int version ) { ar & boost::serialization::make_nvp( "Name", mName ); } public: ~PointedToClass(){} PointedToClass():mName("def"){} }; typedef boost::shared_ptr<PointedToClass> tPtr; class SomeClass { tName mName; tPtr mPtr; friend class boost::serialization::access; template< class Archive > void serialize( Archive &ar, unsigned int version ) { ar & boost::serialization::make_nvp( "Name", mName ); ar & boost::serialization::make_nvp( "Ptr", mPtr ); } public: SomeClass():mName("abc"),mPtr(){} }; int main( int argc, char* argv[] ) { SomeClass lSomeClass; { std::ofstream lOut( "SomeClass.archive", std::ios_base::out | std::ios_base::trunc ); if( lOut.good() ) { boost::archive::xml_oarchive oa( lOut ); oa & boost::serialization::make_nvp( "SomeClass", lSomeClass ); } } { std::ifstream lIn( "SomeClass.archive" ); if( lIn.good() ) { boost::archive::xml_iarchive ia( lIn ); ia & boost::serialization::make_nvp( "SomeClass", lSomeClass ); } } return 0; }

1 0