- Boost - lists.boost.org

Boost Library Authors: BoostCon submission deadline approaching
by Hartmut Kaiser 18 Jan '09

18 Jan '09

Hi all, at last year's BoostCon, one of the highlights was the authors corner track. These were 20-30 minute sessions held by Boost library authors talking about their libraries. Most of the attendees of those sessions found them to be very interesting and useful. At this year's BoostCon we would like to have a similar track again. Unfortunately by now we don't have any related submissions. So I thought I explicitly encourage boost authors who are planning to be in Austin this year to consider giving a 30 minute introductory talk about their libraries. This is not a huge effort in terms of preparation, but adds a lot to the conference. You can find the details about BoostCon and the submission process here: http://www.boostcon.com/program/call-for-sessions. Please spread the word! Regards Hartmut Program Chair

4 8

[uitility/result_of] CodeGear support of result_of
by joaquin＠tid.es 18 Jan '09

18 Jan '09

Hi, Seemingly, CodeGear does not support boost::result_of http://tinyurl.com/8onbjj I propose that this is officially recognized so that including <boost/utility/result_of.hpp> results in BOOST_NO_RESULT_OF being defined rather than the current compile error. This will benefit those result_of-dependent libraries honoring BOOST_NO_RESULT_OF (vg. Boost.Parameter). Joaquín M López Muñoz Telefónica, Investigación y Desarrollo||* *

4 6

[any] Will it be in C++0x?
by Andrey Semashev 17 Jan '09

17 Jan '09

Suddenly, it occurred to me that STL does not provide an instrument for dynamic typed variables (or variants). I didn't see such a tool in TR1 either. So, are there any plans to include such a tool in C++0x? Boost.Any seems to me a very simple, yet very useful example of utility of that kind. It would be great if STL provided a similar instrument out of box.

2 1

[smart_ptr] make_shared performance
by Frank Mori Hess 17 Jan '09

17 Jan '09

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 I've been doing a little benchmarking (trivial benchmark program attached) of boost::make_shared performance. With svn trunk, I don't see much improvement from using make_shared, in fact for large objects it is much slower. I would guess this is due to the increased overhead of copying sp_ms_deleter for large types. I wonder if anyone has any ideas for improving the situation? -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.6 (GNU/Linux) iD8DBQFJcP7d5vihyNWuA4URApVPAJ9EfS6MtkNHTUgb/gOTD/nRngPiUQCeL6K0 MtkmtRAmzKlN1m0eXO9t5k0= =LpQ1 -----END PGP SIGNATURE-----

3 3

[interprocess] Arithmetic error
by Henrik Sundberg 17 Jan '09

17 Jan '09

Disclaimer: I have no minimal reproducing program. The problem occurs at line 458 in mapped_region.hpp: 456 //We calculate the difference between demanded and valid offset 457 std::size_t page_size = this->get_page_size(); 458 m_extra_offset = (offset - (offset / page_size) * page_size); I've found out that page_size gets the value 0. It only seems to happen in my single core computer. It works for other Kubuntu 8.10 systems. The code is needed during so-load. The library is used from two other libraries that are loaded by the program (like a diamond library load). I've been discussing the problem in this forum: http://www.safirsdk.com/forum/phpBB3/viewtopic.php?f=4&t=61 The code is open (available from the site of the forum). It is a whole framework though, not just a small program. I don't know if this is a compiler bug, a Boost bug or a bug in the program. I think that the page size is supposed to be cached, but that this somehow doesn't happen in this setup. I get the error every time. Preloading the library avoids the problem. I.e. starting like this works: LD_PRELOAD=libdots_kernel.so dobexplorer /$

3 3

Mixing protocol
by Joel Falcou 17 Jan '09

17 Jan '09

So far BOOST proposes various prtocols for meta-function : - the result_of protocol - the apply<> protocol of MPL - the ::type protocol of traits Can those protocols be mixed somehow without any side-effects when used with the various aforementionned protocol ? -- ___________________________________________ Joel Falcou - Assistant Professor PARALL Team - LRI - Universite Paris Sud XI Tel : (+33)1 69 15 66 35

3 5

[scope_exit] capture list syntax for scope_exit and local_function
by Alexander Nasonov 16 Jan '09

16 Jan '09

gmane wrote: > The following errors were found. Fix them, and submit again: > You seem to be top-posting. Don't do that. apparently gmane bug. Hi, My current implementation uses ref/cref/val prefixes to pass arguments. It's not consistent with C++0x lambda capture list syntax. scope_exit: (ref a)(cref b)(val c) c++0x: [&a, &b, c] I have a proof-of-concept implementation for BOOST_SCOPE_EXIT( (&a)(&b)(c) ) { std::cout << a << '\n' << b << '\n' << c << '\n'; } BOOST_SCOPE_EXIT_END It does not support passing by reference of classes with overloaded unary operator& but they are rather rare and we can tell users to use reference_wrapper to pass them. Also, it does indirect function call. Gcc 3.4 and 4.2 don't optimize it away even with -O3 but Intel 10.1 does (though, it generates a body of the function even with -Os). What do you think? #include <iostream> #include <boost/mpl/if.hpp> #include <boost/call_traits.hpp> #include <boost/type_traits/is_function.hpp> template<class T> inline T& deref(T* p, boost::false_type) { return *p; } template<class T> inline T& deref(T& r, boost::true_type) { return r; } void foo(int a, long const b, char const c) { int &a_ref_test(); int &b_ref_test(); int c_ref_test(); typedef boost::is_function<typeof(&a_ref_test)> is_not_ref_0; typedef boost::is_function<typeof(&b_ref_test)> is_not_ref_1; typedef boost::is_function<typeof( c_ref_test)> is_not_ref_2; typedef typeof(deref(&a, is_not_ref_0())) value_t_0; typedef typeof(deref(&b, is_not_ref_1())) value_t_1; typedef typeof(deref( c, is_not_ref_2())) value_t_2; typedef boost::mpl::if_< is_not_ref_0, boost::call_traits<value_t_0>::param_type, value_t_0 >::type param_t_0; typedef boost::mpl::if_< is_not_ref_1, boost::call_traits<value_t_1>::param_type, value_t_1 >::type param_t_1; typedef boost::mpl::if_< is_not_ref_2, boost::call_traits<value_t_2>::param_type, value_t_2 >::type param_t_2; struct params_t { value_t_0 &a; value_t_1 &b; value_t_2 c; params_t(param_t_0 &a, param_t_1 &b, param_t_2 c) : a(a), b(b), c(c) {} void invoke(void (*f)(param_t_0 &a, param_t_1 &b, param_t_2 c)) { f( deref(&a, is_not_ref_0()), deref(&b, is_not_ref_1()), deref( c, is_not_ref_2()) ); } }; params_t params( deref(&a, is_not_ref_0()), deref(&b, is_not_ref_1()), deref( c, is_not_ref_2()) ); void* p = ¶ms; struct guard_t { params_t* params; guard_t(void* p) : params((params_t*)p) {} ~guard_t() { params->invoke(&guard_t::body); } static void body(param_t_0 &a, param_t_1 &b, param_t_2 c) { std::cout << a << '\n' << b << '\n' << c << '\n'; } } guard(p); } int main() { foo(0, 1, '2'); } Thanks, Alex

3 4

Library proposal: binconst, constant of the binary form.
by TaeKyeong Wang 16 Jan '09

16 Jan '09

C++ programmers want to input a constant of the binary form, like following. But, this is illegal in C++ world. unsigned char value = 0b10001010; There are some solutions of this lack. But, I can't find the gratifying answer. This proposal has following features. - whether digits is binary form - whether digits is octal or decimal of binary form - range of input octal or decimal number detection - output value is absolutely constant, no charge of resource (code, memory) at a run-time Usage: unsigned int td = BD_( 10101010, 00101100, 11110000, 00001111 ); // OK unsigned short tw = BW_( 00011000, 12345678 ); // Compile Error - invalid binary digit unsigned char tb1 = BB_( 0101 ); // OK. from octal unsigned char tb2 = BB_( 1010 ); // OK. from decimal unsigned char tb3 = BB_( 0111100001 ); // Compile Error - out of octal range unsigned char tb4 = BB_( 111100001 ); // Compile Error - out of decimal range Thanks. ---------- binconst.h template<int> struct CompileTimeCheck; template<> struct CompileTimeCheck<true> { }; /** Determines whether N is octal digits of the binary form. ex 1) octal_test< 0101 > == octal_test< 65 >, 65 % 8 == 1 octal_test< 0010 > == octal_test< 8 >, 8 % 8 == 1 octal_test< 0001 > == octal_test< 1 >, 1 % 8 == 1 octal_test< 0000 > == octal_test< 0 >, 0 % 8 == 0 ex 2) octal_test< 0120 > == octal_test< 80 >, 80 % 8 == 0 octal_test< 0012 > == octal_test< 10 >, 10 % 8 == 2 <--- invalid digit detected!!! octal_test< 0001 > == octal_test< 1 >, 1 % 8 == 1 octal_test< 0000 > == octal_test< 0 >, 0 % 8 == 0 */ template< unsigned int N > struct octal_test { enum { is_octal = (N % 8 <= 1) & octal_test< N / 8 >::is_octal }; }; /** end recursive */ template<> struct octal_test< 0 > { enum { is_octal = 1 }; }; /** Determines whether N is decimal digits of the binary form. */ template< unsigned int N > struct decimal_test { enum { is_decimal = (N % 10 <= 1) & decimal_test< N / 10 >::is_decimal, }; }; /** end recursive */ template<> struct decimal_test< 0 > { enum { is_decimal = 1 }; }; /** Convert octal digits of the binary form to a binary number. */ template< unsigned int N > struct binary_octal { enum { value = N % 8 + 2 * binary_octal< N / 8 >::value }; }; /** end recursive */ template<> struct binary_octal< 0 > { enum { value = 0 }; }; /** Convert decimal digits of the binary form to a binary number. */ template< unsigned int N > struct binary_decimal { enum { value = N % 10 + 2 * binary_decimal< N / 10 >::value }; }; /** end recursive */ template<> struct binary_decimal< 0 > { enum { value = 0 }; }; /** one byte */ template< unsigned int B0 > struct binary_byte { enum { is_octal = octal_test< B0 >::is_octal, is_decimal = decimal_test< B0 >::is_decimal }; static const unsigned int value = is_decimal ? binary_decimal< B0 >::value : binary_octal< B0 >::value; CompileTimeCheck< is_octal * B0 <= 011111111 > Out_Of_Range_Octal; CompileTimeCheck< is_decimal * B0 <= 11111111 > Out_Of_Range_Decimal; CompileTimeCheck< is_octal | is_decimal > Invalid_Binary_Digit; }; /** two bytes */ template< unsigned int B1, unsigned int B0 > struct binary_word { static const unsigned int value = (binary_byte< B1 >::value << 8) + (binary_byte< B0 >::value); }; /** four bytes */ template< unsigned int B3, unsigned int B2, unsigned int B1, unsigned int B0 > struct binary_dword { static const unsigned int value = (binary_word< B3, B2>::value << 16) + binary_word< B1, B0 >::value; }; #define BB_( b0 ) \ binary_byte< b0 >::value #define BW_( b1, b0 ) \ binary_word< b1, b0 >::value #define BD_( b3, b2, b1, b0 ) \ binary_dword< b3, b2, b1, b0 >::value ---------- binconst_test.cpp #include "binconst.h" const unsigned int testd = BD_( 11111111, 00000000, 00000000, 00000101 ); #define CHECK( c ) \ { \ CompileTimeCheck< (c) > error; \ (void)error; \ } int main() { /* Generated assembly code Visual C++ 2008 Express Edition mov DWORD PTR _bd$[ebp], -16777211 ; ff000005H g++ (GCC) 4.2.1 20070719 [FreeBSD] movl $-16777211, -4(%ebp) */ dword bd = BD_( 11111111, 00000000, 00000000, 00000101 ); CHECK( BD_( 11111111, 00000000, 00000000, 00000101 ) == 0XFF000005 ); CHECK( BB_( 0 ) == 0x0 ); CHECK( BB_( 1 ) == 0x1 ); CHECK( BB_( 00 ) == 0x0 ); CHECK( BB_( 01 ) == 0x1 ); CHECK( BB_( 10 ) == 0x2 ); CHECK( BB_( 11 ) == 0x3 ); CHECK( BB_( 000 ) == 0x0 ); CHECK( BB_( 001 ) == 0x1 ); CHECK( BB_( 010 ) == 0x2 ); CHECK( BB_( 011 ) == 0x3 ); CHECK( BB_( 100 ) == 0x4 ); CHECK( BB_( 101 ) == 0x5 ); CHECK( BB_( 110 ) == 0x6 ); CHECK( BB_( 111 ) == 0x7 ); CHECK( BB_( 0000 ) == 0x0 ); CHECK( BB_( 0001 ) == 0x1 ); CHECK( BB_( 0010 ) == 0x2 ); CHECK( BB_( 0011 ) == 0x3 ); CHECK( BB_( 0100 ) == 0x4 ); CHECK( BB_( 0101 ) == 0x5 ); CHECK( BB_( 0110 ) == 0x6 ); CHECK( BB_( 0111 ) == 0x7 ); CHECK( BB_( 1000 ) == 0x8 ); CHECK( BB_( 1001 ) == 0x9 ); CHECK( BB_( 1010 ) == 0xA ); CHECK( BB_( 1011 ) == 0xB ); CHECK( BB_( 1100 ) == 0xC ); CHECK( BB_( 1101 ) == 0xD ); CHECK( BB_( 1110 ) == 0xE ); CHECK( BB_( 1111 ) == 0xF ); CHECK( BB_( 00000000 ) == 0x00 ); CHECK( BB_( 00000001 ) == 0x01 ); CHECK( BB_( 00000010 ) == 0x02 ); CHECK( BB_( 00000011 ) == 0x03 ); CHECK( BB_( 00000100 ) == 0x04 ); CHECK( BB_( 00000101 ) == 0x05 ); CHECK( BB_( 00000110 ) == 0x06 ); CHECK( BB_( 00000111 ) == 0x07 ); CHECK( BB_( 00001000 ) == 0x08 ); CHECK( BB_( 00001001 ) == 0x09 ); CHECK( BB_( 00001010 ) == 0x0A ); CHECK( BB_( 00001011 ) == 0x0B ); CHECK( BB_( 00001100 ) == 0x0C ); CHECK( BB_( 00001101 ) == 0x0D ); CHECK( BB_( 00001110 ) == 0x0E ); CHECK( BB_( 00001111 ) == 0x0F ); CHECK( BB_( 00010000 ) == 0x10 ); CHECK( BB_( 00010001 ) == 0x11 ); CHECK( BB_( 00010010 ) == 0x12 ); CHECK( BB_( 00010011 ) == 0x13 ); CHECK( BB_( 00010100 ) == 0x14 ); CHECK( BB_( 00010101 ) == 0x15 ); CHECK( BB_( 00010110 ) == 0x16 ); CHECK( BB_( 00010111 ) == 0x17 ); CHECK( BB_( 00011000 ) == 0x18 ); CHECK( BB_( 00011001 ) == 0x19 ); CHECK( BB_( 00011010 ) == 0x1A ); CHECK( BB_( 00011011 ) == 0x1B ); CHECK( BB_( 00011100 ) == 0x1C ); CHECK( BB_( 00011101 ) == 0x1D ); CHECK( BB_( 00011110 ) == 0x1E ); CHECK( BB_( 00011111 ) == 0x1F ); CHECK( BB_( 00100000 ) == 0x20 ); CHECK( BB_( 00100001 ) == 0x21 ); CHECK( BB_( 00100010 ) == 0x22 ); CHECK( BB_( 00100011 ) == 0x23 ); CHECK( BB_( 00100100 ) == 0x24 ); CHECK( BB_( 00100101 ) == 0x25 ); CHECK( BB_( 00100110 ) == 0x26 ); CHECK( BB_( 00100111 ) == 0x27 ); CHECK( BB_( 00101000 ) == 0x28 ); CHECK( BB_( 00101001 ) == 0x29 ); CHECK( BB_( 00101010 ) == 0x2A ); CHECK( BB_( 00101011 ) == 0x2B ); CHECK( BB_( 00101100 ) == 0x2C ); CHECK( BB_( 00101101 ) == 0x2D ); CHECK( BB_( 00101110 ) == 0x2E ); CHECK( BB_( 00101111 ) == 0x2F ); CHECK( BB_( 00110000 ) == 0x30 ); CHECK( BB_( 00110001 ) == 0x31 ); CHECK( BB_( 00110010 ) == 0x32 ); CHECK( BB_( 00110011 ) == 0x33 ); CHECK( BB_( 00110100 ) == 0x34 ); CHECK( BB_( 00110101 ) == 0x35 ); CHECK( BB_( 00110110 ) == 0x36 ); CHECK( BB_( 00110111 ) == 0x37 ); CHECK( BB_( 00111000 ) == 0x38 ); CHECK( BB_( 00111001 ) == 0x39 ); CHECK( BB_( 00111010 ) == 0x3A ); CHECK( BB_( 00111011 ) == 0x3B ); CHECK( BB_( 00111100 ) == 0x3C ); CHECK( BB_( 00111101 ) == 0x3D ); CHECK( BB_( 00111110 ) == 0x3E ); CHECK( BB_( 00111111 ) == 0x3F ); CHECK( BB_( 01000000 ) == 0x40 ); CHECK( BB_( 01000001 ) == 0x41 ); CHECK( BB_( 01000010 ) == 0x42 ); CHECK( BB_( 01000011 ) == 0x43 ); CHECK( BB_( 01000100 ) == 0x44 ); CHECK( BB_( 01000101 ) == 0x45 ); CHECK( BB_( 01000110 ) == 0x46 ); CHECK( BB_( 01000111 ) == 0x47 ); CHECK( BB_( 01001000 ) == 0x48 ); CHECK( BB_( 01001001 ) == 0x49 ); CHECK( BB_( 01001010 ) == 0x4A ); CHECK( BB_( 01001011 ) == 0x4B ); CHECK( BB_( 01001100 ) == 0x4C ); CHECK( BB_( 01001101 ) == 0x4D ); CHECK( BB_( 01001110 ) == 0x4E ); CHECK( BB_( 01001111 ) == 0x4F ); CHECK( BB_( 01010000 ) == 0x50 ); CHECK( BB_( 01010001 ) == 0x51 ); CHECK( BB_( 01010010 ) == 0x52 ); CHECK( BB_( 01010011 ) == 0x53 ); CHECK( BB_( 01010100 ) == 0x54 ); CHECK( BB_( 01010101 ) == 0x55 ); CHECK( BB_( 01010110 ) == 0x56 ); CHECK( BB_( 01010111 ) == 0x57 ); CHECK( BB_( 01011000 ) == 0x58 ); CHECK( BB_( 01011001 ) == 0x59 ); CHECK( BB_( 01011010 ) == 0x5A ); CHECK( BB_( 01011011 ) == 0x5B ); CHECK( BB_( 01011100 ) == 0x5C ); CHECK( BB_( 01011101 ) == 0x5D ); CHECK( BB_( 01011110 ) == 0x5E ); CHECK( BB_( 01011111 ) == 0x5F ); CHECK( BB_( 01100000 ) == 0x60 ); CHECK( BB_( 01100001 ) == 0x61 ); CHECK( BB_( 01100010 ) == 0x62 ); CHECK( BB_( 01100011 ) == 0x63 ); CHECK( BB_( 01100100 ) == 0x64 ); CHECK( BB_( 01100101 ) == 0x65 ); CHECK( BB_( 01100110 ) == 0x66 ); CHECK( BB_( 01100111 ) == 0x67 ); CHECK( BB_( 01101000 ) == 0x68 ); CHECK( BB_( 01101001 ) == 0x69 ); CHECK( BB_( 01101010 ) == 0x6A ); CHECK( BB_( 01101011 ) == 0x6B ); CHECK( BB_( 01101100 ) == 0x6C ); CHECK( BB_( 01101101 ) == 0x6D ); CHECK( BB_( 01101110 ) == 0x6E ); CHECK( BB_( 01101111 ) == 0x6F ); CHECK( BB_( 01110000 ) == 0x70 ); CHECK( BB_( 01110001 ) == 0x71 ); CHECK( BB_( 01110010 ) == 0x72 ); CHECK( BB_( 01110011 ) == 0x73 ); CHECK( BB_( 01110100 ) == 0x74 ); CHECK( BB_( 01110101 ) == 0x75 ); CHECK( BB_( 01110110 ) == 0x76 ); CHECK( BB_( 01110111 ) == 0x77 ); CHECK( BB_( 01111000 ) == 0x78 ); CHECK( BB_( 01111001 ) == 0x79 ); CHECK( BB_( 01111010 ) == 0x7A ); CHECK( BB_( 01111011 ) == 0x7B ); CHECK( BB_( 01111100 ) == 0x7C ); CHECK( BB_( 01111101 ) == 0x7D ); CHECK( BB_( 01111110 ) == 0x7E ); CHECK( BB_( 01111111 ) == 0x7F ); CHECK( BB_( 10000000 ) == 0x80 ); CHECK( BB_( 10000001 ) == 0x81 ); CHECK( BB_( 10000010 ) == 0x82 ); CHECK( BB_( 10000011 ) == 0x83 ); CHECK( BB_( 10000100 ) == 0x84 ); CHECK( BB_( 10000101 ) == 0x85 ); CHECK( BB_( 10000110 ) == 0x86 ); CHECK( BB_( 10000111 ) == 0x87 ); CHECK( BB_( 10001000 ) == 0x88 ); CHECK( BB_( 10001001 ) == 0x89 ); CHECK( BB_( 10001010 ) == 0x8A ); CHECK( BB_( 10001011 ) == 0x8B ); CHECK( BB_( 10001100 ) == 0x8C ); CHECK( BB_( 10001101 ) == 0x8D ); CHECK( BB_( 10001110 ) == 0x8E ); CHECK( BB_( 10001111 ) == 0x8F ); CHECK( BB_( 10010000 ) == 0x90 ); CHECK( BB_( 10010001 ) == 0x91 ); CHECK( BB_( 10010010 ) == 0x92 ); CHECK( BB_( 10010011 ) == 0x93 ); CHECK( BB_( 10010100 ) == 0x94 ); CHECK( BB_( 10010101 ) == 0x95 ); CHECK( BB_( 10010110 ) == 0x96 ); CHECK( BB_( 10010111 ) == 0x97 ); CHECK( BB_( 10011000 ) == 0x98 ); CHECK( BB_( 10011001 ) == 0x99 ); CHECK( BB_( 10011010 ) == 0x9A ); CHECK( BB_( 10011011 ) == 0x9B ); CHECK( BB_( 10011100 ) == 0x9C ); CHECK( BB_( 10011101 ) == 0x9D ); CHECK( BB_( 10011110 ) == 0x9E ); CHECK( BB_( 10011111 ) == 0x9F ); CHECK( BB_( 10100000 ) == 0xA0 ); CHECK( BB_( 10100001 ) == 0xA1 ); CHECK( BB_( 10100010 ) == 0xA2 ); CHECK( BB_( 10100011 ) == 0xA3 ); CHECK( BB_( 10100100 ) == 0xA4 ); CHECK( BB_( 10100101 ) == 0xA5 ); CHECK( BB_( 10100110 ) == 0xA6 ); CHECK( BB_( 10100111 ) == 0xA7 ); CHECK( BB_( 10101000 ) == 0xA8 ); CHECK( BB_( 10101001 ) == 0xA9 ); CHECK( BB_( 10101010 ) == 0xAA ); CHECK( BB_( 10101011 ) == 0xAB ); CHECK( BB_( 10101100 ) == 0xAC ); CHECK( BB_( 10101101 ) == 0xAD ); CHECK( BB_( 10101110 ) == 0xAE ); CHECK( BB_( 10101111 ) == 0xAF ); CHECK( BB_( 10110000 ) == 0xB0 ); CHECK( BB_( 10110001 ) == 0xB1 ); CHECK( BB_( 10110010 ) == 0xB2 ); CHECK( BB_( 10110011 ) == 0xB3 ); CHECK( BB_( 10110100 ) == 0xB4 ); CHECK( BB_( 10110101 ) == 0xB5 ); CHECK( BB_( 10110110 ) == 0xB6 ); CHECK( BB_( 10110111 ) == 0xB7 ); CHECK( BB_( 10111000 ) == 0xB8 ); CHECK( BB_( 10111001 ) == 0xB9 ); CHECK( BB_( 10111010 ) == 0xBA ); CHECK( BB_( 10111011 ) == 0xBB ); CHECK( BB_( 10111100 ) == 0xBC ); CHECK( BB_( 10111101 ) == 0xBD ); CHECK( BB_( 10111110 ) == 0xBE ); CHECK( BB_( 10111111 ) == 0xBF ); CHECK( BB_( 11000000 ) == 0xC0 ); CHECK( BB_( 11000001 ) == 0xC1 ); CHECK( BB_( 11000010 ) == 0xC2 ); CHECK( BB_( 11000011 ) == 0xC3 ); CHECK( BB_( 11000100 ) == 0xC4 ); CHECK( BB_( 11000101 ) == 0xC5 ); CHECK( BB_( 11000110 ) == 0xC6 ); CHECK( BB_( 11000111 ) == 0xC7 ); CHECK( BB_( 11001000 ) == 0xC8 ); CHECK( BB_( 11001001 ) == 0xC9 ); CHECK( BB_( 11001010 ) == 0xCA ); CHECK( BB_( 11001011 ) == 0xCB ); CHECK( BB_( 11001100 ) == 0xCC ); CHECK( BB_( 11001101 ) == 0xCD ); CHECK( BB_( 11001110 ) == 0xCE ); CHECK( BB_( 11001111 ) == 0xCF ); CHECK( BB_( 11010000 ) == 0xD0 ); CHECK( BB_( 11010001 ) == 0xD1 ); CHECK( BB_( 11010010 ) == 0xD2 ); CHECK( BB_( 11010011 ) == 0xD3 ); CHECK( BB_( 11010100 ) == 0xD4 ); CHECK( BB_( 11010101 ) == 0xD5 ); CHECK( BB_( 11010110 ) == 0xD6 ); CHECK( BB_( 11010111 ) == 0xD7 ); CHECK( BB_( 11011000 ) == 0xD8 ); CHECK( BB_( 11011001 ) == 0xD9 ); CHECK( BB_( 11011010 ) == 0xDA ); CHECK( BB_( 11011011 ) == 0xDB ); CHECK( BB_( 11011100 ) == 0xDC ); CHECK( BB_( 11011101 ) == 0xDD ); CHECK( BB_( 11011110 ) == 0xDE ); CHECK( BB_( 11011111 ) == 0xDF ); CHECK( BB_( 11100000 ) == 0xE0 ); CHECK( BB_( 11100001 ) == 0xE1 ); CHECK( BB_( 11100010 ) == 0xE2 ); CHECK( BB_( 11100011 ) == 0xE3 ); CHECK( BB_( 11100100 ) == 0xE4 ); CHECK( BB_( 11100101 ) == 0xE5 ); CHECK( BB_( 11100110 ) == 0xE6 ); CHECK( BB_( 11100111 ) == 0xE7 ); CHECK( BB_( 11101000 ) == 0xE8 ); CHECK( BB_( 11101001 ) == 0xE9 ); CHECK( BB_( 11101010 ) == 0xEA ); CHECK( BB_( 11101011 ) == 0xEB ); CHECK( BB_( 11101100 ) == 0xEC ); CHECK( BB_( 11101101 ) == 0xED ); CHECK( BB_( 11101110 ) == 0xEE ); CHECK( BB_( 11101111 ) == 0xEF ); CHECK( BB_( 11110000 ) == 0xF0 ); CHECK( BB_( 11110001 ) == 0xF1 ); CHECK( BB_( 11110010 ) == 0xF2 ); CHECK( BB_( 11110011 ) == 0xF3 ); CHECK( BB_( 11110100 ) == 0xF4 ); CHECK( BB_( 11110101 ) == 0xF5 ); CHECK( BB_( 11110110 ) == 0xF6 ); CHECK( BB_( 11110111 ) == 0xF7 ); CHECK( BB_( 11111000 ) == 0xF8 ); CHECK( BB_( 11111001 ) == 0xF9 ); CHECK( BB_( 11111010 ) == 0xFA ); CHECK( BB_( 11111011 ) == 0xFB ); CHECK( BB_( 11111100 ) == 0xFC ); CHECK( BB_( 11111101 ) == 0xFD ); CHECK( BB_( 11111110 ) == 0xFE ); CHECK( BB_( 11111111 ) == 0xFF ); return 0; }

4 5

[mp_math] Wrong sign for mp_int<> after addition.
by Jeroen N. Witmond 16 Jan '09

16 Jan '09

Greetings, I posted this in the Boost Users list last Sunday, but on second throught perhaps I'd beter post it here. I've stumbled across a problem in mp_math in the sandbox, revision 50541. The code below (a Boost.Test test case) demonstrates that the problem is present only for mp_int<> and not for int. The message I get is wrong-value.cpp(16): error in "Mixed_integers<N5boost7mp_math6mp_intISaIvENS0_13mp_int_traitsIjyEEEE>": check j == 4 failed [-4 != 4] Regards, Jeroen. #define BOOST_TEST_DYN_LINK #define BOOST_TEST_MODULE Wrong_sign #include <boost/test/unit_test.hpp> #include <boost/mp_math/mp_int.hpp> #include <boost/mpl/list.hpp> typedef boost::mpl::list< int, boost::mp_math::mp_int<> > test_types; BOOST_AUTO_TEST_CASE_TEMPLATE( Mixed_integers, Type, test_types ) { Type i(-1); BOOST_CHECK_EQUAL(i, -1); Type j = i + 5; BOOST_CHECK_EQUAL(j, 4); // Line 16. }

2 2

Serialization Link Error
by Venkata (Ravi) Adusumilli 16 Jan '09

16 Jan '09

Hi, BOOST: 1.37 Linux version 2.6.9-efsm (root@vizzini) (gcc version 3.4.6 20060404 (Red Hat 3.4.6-3)) #3 SMP Mon Dec 4 13:14:15 CST 2006 I recieve the following link error: *undefined reference to `void CommandRequest::serialize<boost::archive::xml_iarchive>(boost::archive::xml_iarchive&, unsigned int)'* while compiling the following class: ======H====== #include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/shared_ptr.hpp> class CommandRequest { public: CommandRequest(); CommandRequest(int requestID, int commandType); ~CommandRequest(); int requestID() const; int commandType() const; protected: int requestIDM; int commandTypeM; friend class boost::serialization::access; template<class A> void serialize(A& archive, const unsigned int); }; BOOST_SERIALIZATION_SHARED_PTR(CommunicationObjects::CommandRequest) ======CPP====== CommandRequest::CommandRequest() : requestIDM(0), commandTypeM(0) { } CommandRequest::CommandRequest(int requestID, int commandType) : requestIDM(requestID), commandTypeM(commandType) { } CommandRequest::~CommandRequest() { } int CommandRequest::requestID() const { return requestIDM; } int CommandRequest::commandType() const { return commandTypeM; } template<class A> void CommandRequest::serialize(A & archive, const unsigned int /* version */) { archive & requestIDM; archive & commandTypeM; } template void CommandRequest::serialize<boost::archive::text_oarchive>(boost::archive::text_oarchive& archive, const unsigned int version); template void CommandRequest::serialize<boost::archive::text_iarchive>(boost::archive::text_iarchive& archive, const unsigned int version); Please let me know if you can help me out. -- Thank You, Venkata (Ravi) Adusumilli ------------------------------------------------- "A happy New Year! Grant that I May bring no tear to any eye When this New Year in time shall end Let it be said I've played the friend, Have lived and loved and labored here, And made of it a happy year." ~ Edgar Guest -------------------------------------------------

3 4