December 2004 - Boost - lists.boost.org

Retry: merging all utf8 files
by Vladimir Prus 22 Dec '04

22 Dec '04

Seems like the discussion about how to merge copies of utf8 code used by serialization and program_options has died. I'd like to revive it again, given that I've recieved yet another patch for that code, and the longer we have two versions, the harder it will be to merge them later. The basic question is whether to have a new compiled library in libs/detail, or just source files which will be included by serialization and program_options. The problem with compiled library is that users will have to know that in addition of -lboost_program_options they'll have to add -lboost_utf8, which is inconvenience. I've mentioned this in http://article.gmane.org/gmane.comp.lib.boost.devel/106047/ The proposed course of action is documented in: http://article.gmane.org/gmane.comp.lib.boost.devel/106122 Now: 1. Are there any objections? 2. Who does it? I can do it soon. Robert, what do you think? - Volodya

3 8

Re: [boost] Re: thoughts on a GUI component library
by brangdon＠cix.compulink.co.uk 22 Dec '04

22 Dec '04

In-Reply-To: <cpsv4p$foa$1(a)sea.gmane.org> michaeltoksvig(a)yahoo.com (michael toksvig) wrote (abridged): > you might consider adding operator[] to point and size > > also, consider defining area in terms of 2 points, and adding > operator[] to that, too I was about to say the same thing :-) I'd go further, and expose the array. class box { point data_[2]; public: point *data() { return data_; } static size_t size() { return 2; } point &operator[]( size_t i ) { assert(i < 2); return data_[i]; } // Maybe begin/end too. const point &top_left() { return data_[0]; } const point &bottom_right() { return data_[1]; } float top() { return data_[0][1]; } float left() { return data_[0][0]; } float bottom() { return data_[1][1]; } float right() { return data_[1][0]; } size extent() const { return bottom_right() - top_left(); } float width() const { return right() - left(); } float height() const { return bottom() - top(); } point centre() const { return top_right() + extent()/2; } // ... void set_top_left( const point &p ); void set_top( float f ); void set_centre( const point &p ); // ... }; This is because you will almost certainly want transforms that act on arrays of points, and it will sometimes be convenient if they can act on rectangles too. I would provide get/set methods which are independent of representation. I'd consider allowing things like ++box.top() too. Currently I think the convenience is not worth the loss of purity. ++box[0][1] should work, though. On naming... I think "area" is the wrong name. To me an area can be any shape, or alternatively, every shape has an area. I would expect circle.area() to return pi*r*r. "Rectangle" is better, but what we actually have here is a special kind of rectangle which is aligned with the axis. A rotated rectangle needs more than 2 points. So conceptually we need two rectangle types. I suggest "rectangle" is reserved for the general case, and the aligned one is called "box". As in "bounding box". It has the benefit of being short. I see no benefit in using "position" instead of the usual "point". "Point" is shorter. It's hard to improve on "size" :-) I would seriously consider replacing float with a typedef, perhaps with another typedef for distances and offsets. Even without type checking, I think using more exact type names helps to clarify thought. [Later...] I've looked at the code in the zip file now. I see it doesn't match the email. It uses a different representation and adds several member functions, although not as many as me. I am surprised to see things like size*size and size/size. I see the design is being driven by the needs of a windowing system, when I am being driven by the needs of a graphics/drawing system. That has led to different results, which I suspect is a bad thing. At any rate, it has convinced me that exposing raw member variables (like area.pos) is a mistake. -- Dave Harris, Nottingham, UK

4 4

Re: [boost] Re: thoughts on a GUI component library
by brangdon＠cix.compulink.co.uk 22 Dec '04

22 Dec '04

In-Reply-To: <cq90bq$r7v$1(a)sea.gmane.org> msclrhd(a)hotmail.com (Reece Dunn) wrote (abridged): > > This is because you will almost certainly want transforms that act on > > arrays of points, and it will sometimes be convenient if they can act > > on rectangles too. > > Translation: a.pos += gui::size( 5, 7 ); > Scaling: a.size += gui::size( 10, 20 ); > Rotation: n/a since you are assuming that each side has an angle of 90 > degrees (allowing for two point representations). I'd expect to have a family of transform objects, and in particular a general 2d affine transform represented by a matrix of 6 numbers, along the lines of: x' = x * a + y * b + c; y' = x * d + y * e * e; which can represent scales, shears, rotations, translations or any combination of them. Rotations come into play even for axis-aligned rectangles, although they may be constrained to 90 degree angles. For example, if I want to print a card that will be folded in half horizontally, the top half must be drawn upside-down relative to the bottom half. We probably want to treat it as 2 pages, draw both pages right-way-up and side-by-side in the UI, and then draw the second page upside-down and above the first one to the printer. This kind of thing is useful for 2D graphics. General affine transforms are powerful abstraction. This is an area where I have experience; my only doubt is whether the windowing system can or should use different conventions to the graphics system. And I think you will eventually want everything to be consistent and uniform. > If you have point high, low; then which corner is "high"? Likewise, > using top_left, bottom_right is bad. The same issue arises using (point, size). Which point? It could reasonably be any of the four corners, or the middle. > Having a (point, size) notation, similar to the Cocoa representation, > you remove the need for platform dependancy (except when mapping > between the native type and the independant type). You still need to know whether: r.pos += gui::size( 0, 1 ); moves the rectangle up or down. So you still need to know whether (0,0) is top-left or bottom-left. You have to pick a convention for axis orientation and stick with it, and translate where the native model differs. The orientation of rectangles drops out of the orientation of the axis. Actually, you can sometimes allow a rectangle to be specified by any pair of (diagonally opposite) points, in effect taking their bounding box. This is what PDF does. Usually, though, you normalise the rectangle so that the first point contains the smaller values and the other the larger. Incidently, the conversion from top-left to bottom-left axis orientation is an example of a general transform. It involves both a scale and a translate. > Also, this representation simplifies translation and scaling > (see above). Not really. You have some transforms applied to one member and other transforms to other members. You have to know whether a transform is a scale or a translate before you can apply it. It's not a regular, uniform system; not simple. Also, the code you show for scaling doesn't actually scale. Let's say I have two rectangles side by side: rect a( point(10, 10), size(10, 10) ); rect b( point(20, 10), size(20, 10) ); I want to scale this to double the size. What do I do? gui::size scale( 10, 10 ); a.size += scale; b.size += scale; But that didn't do the job. It made the rectangles overlap, and b's size didn't double. If we actually want that operation, the (point[2]) code is just as simple; you increment the second point. For most operations it makes no difference; neither representation has an advantage. There are probably operations for which (point,size) is slightly easier, and there are other operations for which (point[2]) is easier. I believe (point[2]) is easier for more of the important ones. Testing for point inclusion, and rectangle union, intersection etc, for example. rect intersection( const rect &lhs, const rect &rhs ) { double x0 = max( lhs.point[0].x, rhs.point[0].x ); double y0 = max( lhs.point[0].y, rhs.point[0].y ); double x1 = min( lhs.point[1].x, rhs.point[1].x ); double y1 = min( lhs.point[1].y, rhs.point[1].y ); return rect( x0, y0, x1, y1 ); } versus: rect intersection( const rect &lhs, const rect &rhs ) { double x0 = max( lhs.pos.x, rhs.pos.x ); double y0 = max( lhs.pos.y, rhs.pos.y ); double x1 = min( lhs.pos.x+lhs.size.dx, rhs.pos.x+rhs.size.dx ); double y1 = min( lhs.pos.y+lhs.size.dy, rhs.pos.y+rhs.size.dy ); return rect( x0, y0, x1-x0, y1-y0 ); } The (point,size) version has 6 extra additions or subtractions. > On review, I have removed size/size, size*size. As for the > representation change: this is an evolving library, but the essence > remains the same, so discussion here is still valid. I do not intend on > posting the full member function list as these e-mails are long enough > already! If you are interested, take a look at the code (as you have > done). I appreciate the feedback. The big questions are, should the underlying representation be exposed in the form of public member variables at all? And, does a windowing library need to pay any attention to the needs of a hypothetical drawing library? My answers are "no" and "yes". -- Dave Harris, Nottingham, UK

1 0

Review Request: BOOST_FOREACH
by Eric Niebler 21 Dec '04

21 Dec '04

BOOST_FOREACH is a macro which makes it simple to iterate over a sequence. It is concise, and clearly expresses the programmer's intentions. For example: short array_short[] = {1,2,3}; BOOST_FOREACH( short & i, array_short ) { ++i; } // array_short contains {2,3,4} here Recent changes I have made to the macro have greatly increased its safety and usefulness. It gracefully handles both L-value and R-value sequence expression, and evaluates its arguments only once. It now works (to a greater or lesser extent) on a wide range of compilers, even VC6. The current implementation, documentation and tests can be found in the Boost Sandbox File Vault. You can download the Zip file here: http://tinyurl.com/57oyp Tinyurl link redirects to: http://boost-sandbox.sourceforge.net/vault/index.php?action=downloadfile&fi… -- Eric Niebler Boost Consulting www.boost-consulting.com

7 7

[integer] Solaris integer_traits.hpp #error and general Solaris wchar_t issues
by Caleb Epstein 21 Dec '04

21 Dec '04

The crc library is failing regression tests on Solaris + gcc 3.3.4 (http://tinyurl.com/6qq3y) because of the #error statement on line 112 of integer_traits.hpp (see below). If one includes <wchar.h> before <boost/integer.hpp>, all is well, but if not an error is triggered. Solaris + gcc seems to be a bit of an oddball platform w/r/t wchar_t. It is natively supported and there is a <wchar.h> header, but enough of the C99 wide-character IO routines are missing that gcc does not provide <cwchar>, std::wstring or other related wide features on this platform. The config library sets BOOST_NO_CWCHAR but in integer_traits.hpp I see: 24 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && !defined(BOOST_NO_CWCHAR) 25 #include <wchar.h> 26 #endif There is a <wchar.h> but no <cwchar>. Perhaps there ought to be a config macro BOOST_NO_WCHAR_H that could be used instead of BOOST_NO_CWCHAR in this case, or perhaps just the second part of the #if should be dropped. Here's the section of integer_traits.hpp that is generating the error when <wchar.h> is not first included: 85 #ifndef BOOST_NO_INTRINSIC_WCHAR_T 86 template<> 87 class integer_traits<wchar_t> 88 : public std::numeric_limits<wchar_t>, 89 #if defined(WCHAR_MIN) && defined(WCHAR_MAX) 90 public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX> 91 #elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32_ _) || (defined(__BEOS__) && defined(__GNUC__)) 92 // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned: 93 public detail::integer_traits_base<wchar_t, 0, 0xffff> 94 #elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0 x400))\ 95 || (defined __APPLE__)\ 96 || (defined(__OpenBSD__) && defined(__GNUC__))\ 97 || (defined(__NetBSD__) && defined(__GNUC__))\ 98 || (defined(__FreeBSD__) && defined(__GNUC__))\ 99 || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defi ned(__SGI_STL_PORT)) 100 // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int. 101 // - SGI MIPSpro with native library 102 // - gcc 3.x on HP-UX 103 // - Mac OS X with native library 104 // - gcc on FreeBSD, OpenBSD and NetBSD 105 public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX> 106 #elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !define d(__SGI_STL_PORT) 107 // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigne d int. 108 // - gcc 2.95.x on HP-UX 109 // (also, std::numeric_limits<wchar_t> appears to return the wrong v alues). 110 public detail::integer_traits_base<wchar_t, 0, UINT_MAX> 111 #else 112 #error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits< > for your compiler. 113 #endif 114 { }; 115 #endif // BOOST_NO_INTRINSIC_WCHAR_T -- Caleb Epstein caleb dot epstein at gmail dot com

2 5

question re autolink
by Robert Ramey 21 Dec '04

21 Dec '04

"These macros will be undef'ed at the end of the header, further this header has no include guards - so be sure to include it only once from your library!" What is the rationale for the above? What happens if its violated. I'm sort of struggling implementind a dll version of the serialization library with autolink. The basic difficulty is that I would like to have the dlls mirror the structure of the the static libraries. That is libboost_serialization.lib libboost_wserializaton.lib depends on theabove wserialization.dll is both autolinked and uses serializaton.dll so Its kind of confusing. Robert Ramey

2 1

Re: [boost] Re: thoughts on a GUI component library
by brangdon＠cix.compulink.co.uk 21 Dec '04

21 Dec '04

In-Reply-To: <877e9a1704121705302ac4bce4(a)mail.gmail.com> > Not sure. In computer graphics you specifically talk about > "axis-aligned bounding boxes". To me, "box" is the 3d version of > "rectangle". "Axis-aligned bounding boxes" reflects the importance of being explicit about whether your rectangles are axis-aligned, so I approve, but it's also a bit of a mouthful. I think a shorter name is needed. Some people use AABB, but I'm not keen on acronyms. I'm not keen on abbreviations, too, otherwise using Rect for the axis-aligned case and Rectangle for the general case might work. "Box" was an arbitrary suggestion, in that it does not say "axis aligned" of itself, but I can't think of anything better. For me, in a graphics application, "box" is a term of art which can be either 2d or 3d. Just as points and offsets can also be 2d or 3d (or 1d or 4d). If we care about conflicts with 3d stuff, then maybe we need to be explicit about this, perhaps by using namespaces. Arguably we shouldn't care, because a windowing system is pretty far away from a 3d graphics drawing system. As I realised towards the end of my previous post, perhaps we shouldn't care about 2d graphics, either. It's not so clear-cut because windowing is also 2d; it's easier to see a continuum between them. -- Dave Harris, Nottingham, UK

2 1

boost::noncopyable
by Dirk Gregorius 21 Dec '04

21 Dec '04

Does inheriting from boost::noncopyable has the same effect like making the copy c'tor and the assignment operator private without implementing them? The authors of the smart_ptr library suggest the following for the use of the smart pointers with interfaces: class Interface { public: virtual void f() = 0; virtual void g() = 0; protected: ~Interface( void ) {}; // non-virtual } // #1 class Implementation : public Interface { public: void f() { /* Implementation */ } void g() { /* Implementation */ } private: // Not to be implemented Implementation( const Implementation& ); Implementation& operator=( const Implementation& ); } Does inheriting from boost::noncopyable has the same effect: // # 2 class Implementation : public Interface, /*public or private*/ boost::noncopyable { public: void f() { /* Implementation */ } void g() { /* Implementation */ } } 1.) Are #1 and #2 equivalent? 2.) When should I derive public and when private from boost::noncopyable? 3.) Is the use of noncopyable correct in this context and what are other scenarios when to use it? Regards, -Dirk

6 9

www.boost.org has release information for version 1.33.0
by Douglas Gregor 20 Dec '04

20 Dec '04

It looks like the index.htm from the CVS trunk got pushed to the public web site, but the Version 1.33.0 changes did not get removed. Doug

2 1

Re: [boost] [config][gcc 3.4.2] Request for test about functiontemplate ordering
by JOAQUIN LOPEZ MU?Z 20 Dec '04

20 Dec '04

----- Mensaje original ----- De: Martin Wille <mw8329(a)yahoo.com.au> Fecha: Sábado, Diciembre 18, 2004 10:10 pm Asunto: Re: [boost] [config][gcc 3.4.2] Request for test about functiontemplate ordering > JOAQUIN LOPEZ MU?Z wrote: > > Hi, I've got the hunch that GCC 3.4.2 (specifically, > > the mingw version) might have some problems with > > function template ordering. Could somebody with > > access to that compiler please run the code below > > and report the results? Many thanks in advance. > > "bar-specific" for gcc 3.4.0, gcc 3.4.2, gcc 3.4.3, > gcc 3.3.5, gcc 3.2.3, gcc 3.1 on Linux. > Hi Martin. Well, seems my snippet does not capture the problem, but defiintely there's some difference wrt function template ordering handling between GCC 3.3.x and GCC 3.3.4: the issue is shown here: http://tinyurl.com/3nkgw (GCC 3.4.3 on your regression machine) This is a test for serialization capabilities of Boost.MultiIndex, and it works for GCC <3.4.x. In GCC 3.4.4, hoeever, a user-provided overload of boost::serialization::load_construct_data is not picked up. I guess you have the current CVS downloaded at your machine, since you're publishing regressions. Could you please do me a favor? If so, please define BOOST_NO_FUNCTION_TEMPLATE_ORDERING and rerun Boost.MultiIndex test_serialization for GCC 3.4.4. Boost.Serialization has some machinery to overcome fto problems. Thanks! Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

5 4