June 2004 - Boost - lists.preview.boost.org

RE: [boost] Re: static sized strings (non-virtual implementation)
by Reece Dunn 17 Jun '04

17 Jun '04

John Nagle wrote: >That's a much better approach than the previous one. >It's sound C++, and it's simple. >All the operations go in string_base. fixed_string >need only allocate space. I have now checked in a working implementation of the approach I suggested. It uses a trick to pass the information to the implementation via the basic_string_impl class and has a complicated implementation of swap (non-virtual :)!). The only functions not available to [w]char_string are substr and +, but these are available in fixed_string itself. I have also fixed the problems with fsstring.hpp and Borland, since Borland may make strcpy, etc macro functions to its intrinsic versions (__strcpy__, etc.) Regards, Reece _________________________________________________________________ Want to block unwanted pop-ups? Download the free MSN Toolbar now! http://toolbar.msn.co.uk/

1 0

type_traits for checking derived type
by D-Swat 17 Jun '04

17 Jun '04

Hi, some code: template <typename DerivedT> class A { BOOST_STATIC_ASSERT((boost::is_convertible<A<DerivedT>*, B*>::value)); [...] }; class B : public A<B> { }; I want to check if the template parameter really specifies a derived type. But the assert is always false. How can i solve this? bye

5 5

Re: Boost Digest, Vol 756, Issue 1
by Eric Ford 17 Jun '04

17 Jun '04

> The next version of my physical quantities library pqs-1-01-04 is > available on my site at: > > http://www.servocomm.freeserve.co.uk/Cpp/pqs-1-01-04/download.html > ... Andy, Thank you for your work on this very important area of development. From just quickly looking at the examples, it appears that you choose to use different types for quantities that have the same dimensions but different units. I don't think that is a good idea. You can search the archives for the discussions several of us had about similar issues, mostly a few years ago. If you still disagree, I'd like to hear why. Perhaps, you could summarize the main similarities and difference between your library and other similar libraries. For example, there's Walter Brown's SIUnits, as well as a couple of drafts that have been uploaded to the boost vault. I know I posted ebf_units a while back to give people something to work from. And I believe there were one or two others there as well. Thanks, Eric

2 1

applied patch to boost::tuple
by Toon Knapen 17 Jun '04

17 Jun '04

I just applied the patch below to boost/tuple/detail/tuple_basic.hpp to port it to IBM/VisualAge. I tried to contact Jaako Jarvi but the email address listed in the copyright statement is not valid anymore ;-( Index: tuple_basic.hpp =================================================================== RCS file: /cvsroot/boost/boost/boost/tuple/detail/tuple_basic.hpp,v retrieving revision 1.23 retrieving revision 1.24 diff -u -r1.23 -r1.24 --- tuple_basic.hpp 28 Oct 2003 09:42:43 -0000 1.23 +++ tuple_basic.hpp 17 Jun 2004 07:01:13 -0000 1.24 @@ -43,6 +43,8 @@ #include "boost/type_traits/cv_traits.hpp" #include "boost/type_traits/function_traits.hpp" +#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND + namespace boost { namespace tuples { @@ -97,12 +99,22 @@ template<class RET, class HT, class TT > inline static RET get(const cons<HT, TT>& t) { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + // vacpp 6.0 is not very consistent regarding the member template keyword + // Here it generates an error when the template keyword is used. + return get_class<N-1>::get<RET>(t.tail); +#else return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail); +#endif } template<class RET, class HT, class TT > inline static RET get(cons<HT, TT>& t) { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return get_class<N-1>::get<RET>(t.tail); +#else return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail); +#endif } }; @@ -194,11 +206,17 @@ typename element<N, cons<HT, TT> >::type >::non_const_type get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { - return detail::get_class<N>::BOOST_NESTED_TEMPLATE +#if BOOST_WORKAROUND(__IBMCPP__,==600 ) + return get_class<N>:: +#else + return get_class<N>::BOOST_NESTED_TEMPLATE +#endif get< typename access_traits< typename element<N, cons<HT, TT> >::type - >::non_const_type>(c); + >::non_const_type, + HT,TT + >(c); } // get function for const cons-lists, returns a const reference to @@ -209,11 +227,17 @@ typename element<N, cons<HT, TT> >::type >::const_type get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return detail::get_class<N>:: +#else return detail::get_class<N>::BOOST_NESTED_TEMPLATE +#endif get< typename access_traits< typename element<N, cons<HT, TT> >::type - >::const_type>(c); + >::const_type, + HT,TT + >(c); } // -- the cons template --------------------------------------------------

2 1

RE: [boost] Boost.Test
by Roman Yakovenko 17 Jun '04

17 Jun '04

Jagmohan wrote: > Is it possible to just carve out Boost.test package > separately from entire > Boost? Yes, bcp utility is your friend. >From bcp documentation: "The bcp utility is a tool for extracting subsets of Boost, it's useful for Boost authors who want to distribute their library separately from Boost, and for Boost users who want to distribute a subset of Boost with their application." Roman --- Outgoing mail is certified Virus Free. Checked by AVG anti-virus system (http://www.grisoft.com) Version: 6.0.707 / Virus Database: 463 - Release Date: 6/15/2004

1 0

RE: [boost] Re: static sized strings (struct hack)
by Reece Dunn 17 Jun '04

17 Jun '04

John Nagle wrote: > I think we're back to using an abstract base class. >The hacks to get around it introduce worse problems. I would agree. I have been trying to find a way around the problem and have (sortof) by having a base class: template< typename CharT > class string_base { private: size_t len, cap; // length & capacity CharT * buf; // data buffer public: string_base( CharT * b, size_t c, size_t l ): len( l ), cap( c ), buf( b ){} // non-virtual implementation }; template< size_t n, typename CharT > class fixed_string: public string_base { private: CharT data[ n + 1 ]; public: fixed_string(): string_base( data, n + 1 ){} }; The problems with this revolve around swapping/construction/copying and interfacing with (in my case) basic_string_impl. I cannot find a way around these problems without sacrificing something. > Take a look at my approach at >http://www.animats.com/source/index.html > >That's a straightforward approach. The only >fundamental objection is that you take a virtual function >call overhead on some operations. That's the same with both approaches. Both designs are fundamentally the same and I don't see a way around this. It would be interesting to do a comparison with the 3 approaches (raw strcpy, etc on a char[ n ] buffer; your approach and mine) in virtual and non-virtual situations to compare performance. >What needs to be done to that? Are you aiming at supporting basic_string operations? If so, the class needs more work (all the find functions, for instance). If, however, you are just going for C-string replacement it is fine. One point on naming: the wide-character operations are wcscpy (strcpy), wcscat (strcat), wcscmp (strcmp), wcslen (strlen) and [v]swprintf (sprintf). >Should I check it into the Boost sandbox, and >if so, how? Comments, please. Thanks. Go for it! You need a sourceforge account with CVS write access to the boost-sandbox. There is documentation at the sourceforge site for setting it up and pointers to the various tools. You will need to contact an administrator for write access once you have the sourceforge stuff setup. Regards, Reece _________________________________________________________________ Express yourself with cool new emoticons http://www.msn.co.uk/specials/myemo

3 3

Two bugs generating docs using bjam --v2
by Angus Leeming 16 Jun '04

16 Jun '04

I have been following Douglas Gregor's prescriptions on how to generate boostbook docs, outlined on the boost web pages. All works beautifully, so many thanks. However, I find that generating reference docs using bjam and doxygen results in a couple of errors in the docs. I don't know whether the problem lies in bjam or in doxygen, but thought you should have a heads up. This is all with boost-jam-3.1.9-1 doxygen-1.3.4-1 Example 1 A header file containing: template <typename DataT> class process_base { protected: process_base(); process_base(process_base const &); }; results in docs: template<typename DataT> class process_base { public: // construct/copy/destruct process_base(); process_base(process_base const }; Note the change from 'protected' to 'public'. Example 2. This class: struct pprocess_data { /// Type used for file descriptors. typedef int fd_t; /// Pipe used to write to child process' stdin. fd_t wpipe; /// Two pipes to read from child process' stdout and stderr. fd_t rpipe[2]; }; results in these docs: struct pprocess_data { // types typedef int fd_t; // Type used for file descriptors. // public member functions fd_t wpipe; fd_t rpipe; }; Note that the 'rpipe' is no longer an array. Also, shouldn't the 'public member functions' comment be supressed? bjam warning messages are: Cannot handle sectiondef with kind=private-type Cannot handle sectiondef with kind=private-attrib Cannot handle sectiondef with kind=related Cannot handle sectiondef with kind=protected-type Cannot handle sectiondef with kind=protected-attrib I can supply header files and jamfile if required. Regards, Angus

2 2

[bind] Patch that enables pass-by-value
by Lars Rune Nøstdal 16 Jun '04

16 Jun '04

Hi, I'm a new user of this library, so not sure if this is a good idea or the best way to do this. void f(int x) { cout << "f(int): " << x << endl; } int x = 0; bind(f, _1)(x); //bind(f, _1)(1); // Does not work. bind(f, _1)(val<int>(1)); // But this does after patching. This enables the user to pass-by-value if he specifies it explicitly, here is the patch: Index: boost/bind.hpp =================================================================== RCS file: /cvsroot/boost/boost/boost/bind.hpp,v retrieving revision 1.36 diff -u -c -d -r1.36 bind.hpp *** boost/bind.hpp 8 Jun 2004 13:43:03 -0000 1.36 --- boost/bind.hpp 15 Jun 2004 19:13:43 -0000 *************** *** 27,32 **** --- 27,33 ---- #include <boost/type.hpp> #include <boost/bind/arg.hpp> #include <boost/detail/workaround.hpp> + #include <boost/val.hpp> // Borland-specific bug, visit_each() silently fails to produce code Index: boost/bind/bind_template.hpp =================================================================== RCS file: /cvsroot/boost/boost/boost/bind/bind_template.hpp,v retrieving revision 1.4 diff -u -c -d -r1.4 bind_template.hpp *** boost/bind/bind_template.hpp 7 Mar 2004 16:39:15 -0000 1.4 --- boost/bind/bind_template.hpp 15 Jun 2004 19:13:43 -0000 *************** *** 27,32 **** --- 27,38 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1> result_type operator()(val<A1> a1) + { + list1<A1> a(a1); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1> result_type operator()(A1 & a1) { list1<A1 &> a(a1); *************** *** 39,44 **** --- 45,56 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2> result_type operator()(val<A1> a1, val<A2> a2) + { + list2<A1, A2> a(a1, a2); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) { list2<A1 &, A2 &> a(a1, a2); *************** *** 51,56 **** --- 63,74 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3) + { + list3<A1, A2, A3> a(a1, a2, a3); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) { list3<A1 &, A2 &, A3 &> a(a1, a2, a3); *************** *** 63,68 **** --- 81,92 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4) + { + list4<A1, A2, A3, A4> a(a1, a2, a3, a4); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) { list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4); *************** *** 75,80 **** --- 99,110 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4, class A5> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5) + { + list5<A1, A2, A3, A4, A5> a(a1, a2, a3, a4, a5); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) { list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5); *************** *** 87,92 **** --- 117,128 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6) + { + list6<A1, A2, A3, A4, A5, A6> a(a1, a2, a3, a4, a5, a6); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) { list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6); *************** *** 99,104 **** --- 135,146 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7) + { + list7<A1, A2, A3, A4, A5, A6, A7> a(a1, a2, a3, a4, a5, a6, a7); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) { list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7); *************** *** 111,116 **** --- 153,164 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7, val<A8> a8) + { + list8<A1, A2, A3, A4, A5, A6, A7, A8> a(a1, a2, a3, a4, a5, a6, a7, a8); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) { list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8); *************** *** 123,128 **** --- 171,182 ---- BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7, val<A8> a8, val<A9> a9) + { + list9<A1, A2, A3, A4, A5, A6, A7, A8, A9> a(a1, a2, a3, a4, a5, a6, a7, a8, a9); + BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); + } + template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) { list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9); *** /dev/null Thu Jan 1 01:00:00 1970 --- boost/val.hpp Tue Jun 15 22:00:29 2004 *************** *** 0 **** --- 1,35 ---- + #ifndef BOOST_VAL_HPP_INCLUDED + #define BOOST_VAL_HPP_INCLUDED + + // val.hpp - Usefull helper functions + // + // Copyright (C) 2004 Lars Rune Nøstdal (larsnostdal(a)organizer.net) + // + /* + Distributed under 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) + */ + + + namespace boost { + + template<typename T> + struct val { + val(T t) + :value(t) + { + } + + operator T&() + { + return(value); + } + + private: + T value; + }; // val + + } // namespace boost + + #endif // #ifndef BOOST_VAL_HPP_INCLUDED Thanks, Lars Rune Nøstdal

3 3

[tuple] problem with global tuples::get() in vacpp 6.00
by Joaquín Mª López Muñoz 16 Jun '04

16 Jun '04

Seems like Visual Age is having trouble deducing some implicit template parms inside tuples::get(). This is currently breaking Boost.MultiIndex and a test of Boost.Iterator. Please find below a very simple and totally conformant fix. This has not actually been tested with vacpp, but I checked it does not break anything with some other compilers. 1. Could anybody check locally if this solves the aforementioned problems in vacpp? 2. If 1 is positive, can I commit this to the CVS? Anyone sees a problem? Thank you, Joaquín M López Muñoz Telefónica, Investigación y Desarrollo **************DIFF************** 201c201,203 < >::non_const_type>(c); --- > >::non_const_type, > HT,TT > >(c); 216c218,220 < >::const_type>(c); --- > >::const_type, > HT,TT > >(c);

4 11

Geometric Algebra Library
by Jaap Suter 16 Jun '04

16 Jun '04

Hi, This is a follow-up to my original email from June 9th, see: http://tinyurl.com/3defq [again crossposted to oo-numerics and boost-developers] After this email, several people expressed interest in my geometric algebra library. Unfortunately I cannot address each email individually, so thanks to everybody that replied. First, I want to introduce a new feature I added this week.. It's what I like to call the "auto_element" feature. Within the Clifford framework it works like a "typeof" or "auto" feature. Consider the following: typedef algebra<float, 4, 1> conformal_space; element<list_c<int, 0, 2>, conformal_space> a; element<list_c<int, 1, 2, 4>, conformal_space> b; some_type c = left_contraction(a, b) * outer_product(some_vector, some_bi_vector); People familiar with Clifford algebra know that sometimes it is hard to decude what grades appear in the resulting element of a complicated expression. E.g., in the above example, who can tell me what grades appear in the left_contraction of a conformal-spinor and an element that has grade 1, 2 and 4. Let alone if you multiply that with the outer_product of some vector and some bivector. In other words, what is the type of c? Most other libraries solve this by just using a full multivector (consisting of 32 floats) in this case, which is often redundant. In fact, perhaps the above expression results in just a single scalar. That's a lot of calculation and storge for just one number then. This library allows you to write: auto_element(conformal_space, c, left_contraction(a, b) * outer_product(some_vector, some_bi_vector) ); [indention weird, because of the line-ending limit] which will declare an multi-vector of a type that contains the bare-minimum of grades necessary to capture all the information available in the expression. This has big performance improvements, but more interesting, it makes generic programming with arbitrary elements of an algebra a lot of fun. You don't have to know what types are involved in an expression anymore, but still get all the benefits of static type-checking and the associated performance analysis. Who said C++ was statically typed? :) By the way, for those wondering how I did it, obviously auto_element is a macro that does some (compile-time) stuff. It's not that hard, but a technique I hadn't seen before (let me know if it does exist somewhere else, or if there's a better way of doing this). Come to think of it, other libraries that involve dimensional-types (matrix libraries, etc.) could possible benefit from this as well. Anyway, enough about that... I have now uploaded a package to http://www.jaapsuter.com containing all the header files, some of my unit-tests, and the MSVC 7.1 project file. For reasons outside of my control I cannot upload all of the unit-tests yet. This will be resolved shortly. If you consider porting this to GCC, I would still recommend trying to compile the project in MSVC first and play around with it. It's some really heavy code internally. Hopefully (this is for you to judge) the client-side (see the unit-tests) are very friendly though. So please browse the tests before you dive into the implementation. Comments are welcome. There is still some bugs with certain expressions (as a consequence of not being able to deal with unsorted grade-lists), this will be fixed shortly. I am working on the library on-going, but I am hoping somebody will join. Then, somebody mentioned the interoperability with std::complex and Hubert Holin's Quaternion and Octonion library. I have some tests that test whether Clifford and these libraries behave the same (and inter-operate). As for implementing these types in terms of a geometric algebra? It depends. Sometimes it's worthwhile to specialize and keep things simple (think about scoped_ptr not being implemented in terms of a policy_ptr). But then again, if you have a clifford library in your project already anyway, you might as well use it for complex numbers, quaternions, etcetera. Otherwise, using clifford to provide these basic components is probably overkill. Regards, Jaap Suter

2 1