January 2009 - Boost - lists.preview.boost.org

[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

Extra functions for filesystem
by Walter Landry 16 Jan '09

16 Jan '09

Greetings, A long, long time ago, I proposed adding a few more convenience functions to filesystem. http://lists.boost.org/Archives/boost/2006/08/109740.php Despite a positive response and a followup patch, those functions never got incorporated. Did it just fall through the cracks, or was there a more substantive reason those functions never got added? Otherwise, it does not seem possible to implement "cp -a". Thanks, Walter Landry wlandry(a)caltech.edu

3 3

[proto] subscript_wrapper and templated operator[]
by David Deakins 15 Jan '09

15 Jan '09

While using proto with some classes that have a templated operator[] on VC8 and VC9, I have run into a '2 overloads have similar conversions' ambiguity error (C2666). The problem seems to be with subscript_wrapper in detail/decltype.hpp, where neither the templated operator[] from the original class nor the fallback 'any operator[](any)' function in subscript_wrapper have priority. Any thoughts on how to tweak subscript_wrapper so that the 'any operator[](any)' function looks like a worse match than the templated operator[] and thus prevents the ambiguity? I attached a small test case that reproduces the problem. Also, for reference, I am using the proto code from the release branch as of a couple days ago (~12 Jan 2009). Thanks, -Dave #include <boost/proto/proto.hpp> using namespace boost; struct Abc { template <typename T> void operator[](T const & t) { } }; template< typename Expr > void evaluate( Expr const & expr ) { proto::default_context ctx; proto::eval(expr, ctx); } int main() { Abc a; evaluate( proto::lit(a) [ 0 ] ); return 0; }

2 3

Futures - Reviews Needed (January 5, 2009)
by Tom Brinkman 15 Jan '09

15 Jan '09

>> Is the expected result of the review to choose a library (or none) or to >> create a third library that is a mixture of the two? I have no expectations about the results. I'm interested to hear your views and those of the authors about how to proceed.

3 2