mirror of
https://github.com/boostorg/utility.git
synced 2025-10-05 21:40:59 +02:00
Compare commits
66 Commits
boost-1.40
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
|
f009e6754d | ||
|
67f3ca090a | ||
|
|
8efae71f4a | ||
|
ad0bcf4a00 | ||
|
f1c86c35c4 | ||
|
a5b85eda07 | ||
|
bafe37fdab | ||
|
be50b95508 | ||
|
96d573d6ca | ||
|
2412b864d6 | ||
|
|
94865eabe6 | ||
|
|
50268d1b29 | ||
|
|
ad9108c1dc | ||
|
|
691e4b6c34 | ||
|
|
28596e678d | ||
|
|
1beca24dd8 | ||
|
|
721764937f | ||
|
|
a511007d0f | ||
|
|
8ce58b1675 | ||
|
|
9ed68b8321 | ||
|
|
79bbf71d0d | ||
|
|
ac93de7c1b | ||
|
|
d731b8e1c5 | ||
|
|
ac1567b3fc | ||
|
|
c1fd670480 | ||
|
|
01274cf6ac | ||
|
|
8080673977 | ||
|
|
a470b591fb | ||
|
|
e1a63495b6 | ||
|
|
7300ac83f1 | ||
|
|
882d38c2c7 | ||
|
|
33041ad664 | ||
|
|
6a2aa822f8 | ||
|
|
09ab16bfc1 | ||
|
|
ec46e40809 | ||
|
|
b3a971e7e9 | ||
|
|
7ddb559887 | ||
|
|
ea8c99b1d5 | ||
|
|
56b0846099 | ||
|
|
42e0001370 | ||
|
|
cd8f85afee | ||
|
bddd52c4b9 | ||
|
|
8f03aeac4e | ||
|
|
3bb2568fad | ||
|
01e91a3799 | ||
|
|
55f3c351a3 | ||
|
3f72b10182 | ||
|
71cb8cb574 | ||
|
c950825ef4 | ||
|
|
66ca84a45d | ||
|
|
06404f7d39 | ||
|
|
2d860e2574 | ||
|
|
66514f61ff | ||
|
|
63cde4d3fd | ||
|
|
1950f292df | ||
|
92a0602190 | ||
|
|
c9a3ab1d04 | ||
|
|
0782034333 | ||
|
|
0808883f3c | ||
|
|
2f69501e55 | ||
|
|
5b83f641a8 | ||
|
c730ab4ffb | ||
|
e55610a0d0 | ||
|
bf968794c9 | ||
|
|
ce6e9c6698 | ||
|
|
7ac180ed54 |
@@ -85,7 +85,7 @@
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
#
|
||||
# Copyright Troy D. Straszheim
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See http://www.boost.org/LICENSE_1_0.txt
|
||||
#
|
||||
#----------------------------------------------------------------------------
|
||||
# This file was automatically generated from the original CMakeLists.txt file
|
||||
# Add a variable to hold the headers for the library
|
||||
set (lib_headers
|
||||
assert.hpp
|
||||
call_traits.hpp
|
||||
checked_delete.hpp
|
||||
compressed_pair.hpp
|
||||
current_function.hpp
|
||||
operators.hpp
|
||||
throw_exception.hpp
|
||||
utility.hpp
|
||||
utility
|
||||
)
|
||||
|
||||
# Add a library target to the build system
|
||||
boost_library_project(
|
||||
utility
|
||||
# SRCDIRS
|
||||
TESTDIRS test swap/test enable_if/test
|
||||
HEADERS ${lib_headers}
|
||||
# DOCDIRS
|
||||
DESCRIPTION "Various small utilities for C++ programming."
|
||||
MODULARIZED
|
||||
AUTHORS "David Abrahams <dave -at- boostpro.com>"
|
||||
"Brad King"
|
||||
"Douglas Gregor <doug.gregor -at- gmail.com>"
|
||||
# MAINTAINERS
|
||||
)
|
||||
|
||||
|
||||
@@ -509,7 +509,7 @@ Returns the largest size that this Collection can ever have. <A href="#8">[8]</A
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -160,7 +160,7 @@ t.~T()
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -185,7 +185,7 @@
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -70,7 +70,7 @@
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
// addressof_fn_test.cpp: addressof( f )
|
||||
//
|
||||
// Copyright (c) 2008, 2009 Peter Dimov
|
||||
//
|
||||
// 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
|
||||
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
|
||||
void f0()
|
||||
{
|
||||
}
|
||||
|
||||
void f1(int)
|
||||
{
|
||||
}
|
||||
|
||||
void f2(int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f3(int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f4(int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f5(int, int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f6(int, int, int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f7(int, int, int, int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f8(int, int, int, int, int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
void f9(int, int, int, int, int, int, int, int, int)
|
||||
{
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
BOOST_TEST( boost::addressof( f0 ) == &f0 );
|
||||
BOOST_TEST( boost::addressof( f1 ) == &f1 );
|
||||
BOOST_TEST( boost::addressof( f2 ) == &f2 );
|
||||
BOOST_TEST( boost::addressof( f3 ) == &f3 );
|
||||
BOOST_TEST( boost::addressof( f4 ) == &f4 );
|
||||
BOOST_TEST( boost::addressof( f5 ) == &f5 );
|
||||
BOOST_TEST( boost::addressof( f6 ) == &f6 );
|
||||
BOOST_TEST( boost::addressof( f7 ) == &f7 );
|
||||
BOOST_TEST( boost::addressof( f8 ) == &f8 );
|
||||
BOOST_TEST( boost::addressof( f9 ) == &f9 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
// Copyright (C) 2002 Brad King (brad.king@kitware.com)
|
||||
// Douglas Gregor (gregod@cs.rpi.edu)
|
||||
//
|
||||
// Copyright 2009 Peter Dimov
|
||||
//
|
||||
// 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)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
|
||||
#include <boost/utility/addressof.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
template<class T> void scalar_test( T * = 0 )
|
||||
{
|
||||
T* px = new T();
|
||||
|
||||
T& x = *px;
|
||||
BOOST_TEST( boost::addressof(x) == px );
|
||||
|
||||
const T& cx = *px;
|
||||
const T* pcx = boost::addressof(cx);
|
||||
BOOST_TEST( pcx == px );
|
||||
|
||||
volatile T& vx = *px;
|
||||
volatile T* pvx = boost::addressof(vx);
|
||||
BOOST_TEST( pvx == px );
|
||||
|
||||
const volatile T& cvx = *px;
|
||||
const volatile T* pcvx = boost::addressof(cvx);
|
||||
BOOST_TEST( pcvx == px );
|
||||
|
||||
delete px;
|
||||
}
|
||||
|
||||
template<class T> void array_test( T * = 0 )
|
||||
{
|
||||
T nrg[3] = {1,2,3};
|
||||
T (*pnrg)[3] = &nrg;
|
||||
BOOST_TEST( boost::addressof(nrg) == pnrg );
|
||||
|
||||
T const cnrg[3] = {1,2,3};
|
||||
T const (*pcnrg)[3] = &cnrg;
|
||||
BOOST_TEST( boost::addressof(cnrg) == pcnrg );
|
||||
}
|
||||
|
||||
class convertible {
|
||||
public:
|
||||
|
||||
convertible( int = 0 )
|
||||
{
|
||||
}
|
||||
|
||||
template<class U> operator U () const
|
||||
{
|
||||
return U();
|
||||
}
|
||||
};
|
||||
|
||||
class convertible2 {
|
||||
public:
|
||||
|
||||
convertible2( int = 0 )
|
||||
{
|
||||
}
|
||||
|
||||
operator convertible2* () const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
scalar_test<convertible>();
|
||||
scalar_test<convertible2>();
|
||||
|
||||
array_test<convertible>();
|
||||
array_test<convertible2>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
643
binary_test.cpp
643
binary_test.cpp
@@ -1,643 +0,0 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2006, 2007 Matthew Calabrese
|
||||
|
||||
Use, modification and distribution is subject to 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)
|
||||
==============================================================================*/
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/utility/binary.hpp>
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
|
||||
/*
|
||||
Note: This file tests every single valid bit-grouping on its own, and some
|
||||
random combinations of bit-groupings.
|
||||
*/
|
||||
|
||||
std::size_t const num_random_test_values = 32;
|
||||
|
||||
// Note: These hex values should all correspond with the binary array below
|
||||
unsigned int const random_unsigned_ints_hex[num_random_test_values]
|
||||
= { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
|
||||
, 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
|
||||
, 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
|
||||
, 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
|
||||
};
|
||||
|
||||
unsigned int const random_unsigned_ints_binary[num_random_test_values]
|
||||
= { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111 101011 )
|
||||
, BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
|
||||
, BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
|
||||
, BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
|
||||
, BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
|
||||
, BOOST_BINARY( 11 010 000111 01001 ), BOOST_BINARY( 00100 010110 01000 )
|
||||
, BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
|
||||
, BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
|
||||
, BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
|
||||
, BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
|
||||
, BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
|
||||
, BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
|
||||
, BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
|
||||
, BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110 10001 001110 0 )
|
||||
, BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
|
||||
, BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_1_bit[2] =
|
||||
{ BOOST_BINARY( 0 )
|
||||
, BOOST_BINARY( 1 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_2_bits[4] =
|
||||
{ BOOST_BINARY( 00 )
|
||||
, BOOST_BINARY( 01 )
|
||||
, BOOST_BINARY( 10 )
|
||||
, BOOST_BINARY( 11 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_3_bits[8] =
|
||||
{ BOOST_BINARY( 000 )
|
||||
, BOOST_BINARY( 001 )
|
||||
, BOOST_BINARY( 010 )
|
||||
, BOOST_BINARY( 011 )
|
||||
, BOOST_BINARY( 100 )
|
||||
, BOOST_BINARY( 101 )
|
||||
, BOOST_BINARY( 110 )
|
||||
, BOOST_BINARY( 111 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_4_bits[16] =
|
||||
{ BOOST_BINARY( 0000 )
|
||||
, BOOST_BINARY( 0001 )
|
||||
, BOOST_BINARY( 0010 )
|
||||
, BOOST_BINARY( 0011 )
|
||||
, BOOST_BINARY( 0100 )
|
||||
, BOOST_BINARY( 0101 )
|
||||
, BOOST_BINARY( 0110 )
|
||||
, BOOST_BINARY( 0111 )
|
||||
, BOOST_BINARY( 1000 )
|
||||
, BOOST_BINARY( 1001 )
|
||||
, BOOST_BINARY( 1010 )
|
||||
, BOOST_BINARY( 1011 )
|
||||
, BOOST_BINARY( 1100 )
|
||||
, BOOST_BINARY( 1101 )
|
||||
, BOOST_BINARY( 1110 )
|
||||
, BOOST_BINARY( 1111 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_5_bits[32] =
|
||||
{ BOOST_BINARY( 00000 )
|
||||
, BOOST_BINARY( 00001 )
|
||||
, BOOST_BINARY( 00010 )
|
||||
, BOOST_BINARY( 00011 )
|
||||
, BOOST_BINARY( 00100 )
|
||||
, BOOST_BINARY( 00101 )
|
||||
, BOOST_BINARY( 00110 )
|
||||
, BOOST_BINARY( 00111 )
|
||||
, BOOST_BINARY( 01000 )
|
||||
, BOOST_BINARY( 01001 )
|
||||
, BOOST_BINARY( 01010 )
|
||||
, BOOST_BINARY( 01011 )
|
||||
, BOOST_BINARY( 01100 )
|
||||
, BOOST_BINARY( 01101 )
|
||||
, BOOST_BINARY( 01110 )
|
||||
, BOOST_BINARY( 01111 )
|
||||
, BOOST_BINARY( 10000 )
|
||||
, BOOST_BINARY( 10001 )
|
||||
, BOOST_BINARY( 10010 )
|
||||
, BOOST_BINARY( 10011 )
|
||||
, BOOST_BINARY( 10100 )
|
||||
, BOOST_BINARY( 10101 )
|
||||
, BOOST_BINARY( 10110 )
|
||||
, BOOST_BINARY( 10111 )
|
||||
, BOOST_BINARY( 11000 )
|
||||
, BOOST_BINARY( 11001 )
|
||||
, BOOST_BINARY( 11010 )
|
||||
, BOOST_BINARY( 11011 )
|
||||
, BOOST_BINARY( 11100 )
|
||||
, BOOST_BINARY( 11101 )
|
||||
, BOOST_BINARY( 11110 )
|
||||
, BOOST_BINARY( 11111 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_6_bits[64] =
|
||||
{ BOOST_BINARY( 000000 )
|
||||
, BOOST_BINARY( 000001 )
|
||||
, BOOST_BINARY( 000010 )
|
||||
, BOOST_BINARY( 000011 )
|
||||
, BOOST_BINARY( 000100 )
|
||||
, BOOST_BINARY( 000101 )
|
||||
, BOOST_BINARY( 000110 )
|
||||
, BOOST_BINARY( 000111 )
|
||||
, BOOST_BINARY( 001000 )
|
||||
, BOOST_BINARY( 001001 )
|
||||
, BOOST_BINARY( 001010 )
|
||||
, BOOST_BINARY( 001011 )
|
||||
, BOOST_BINARY( 001100 )
|
||||
, BOOST_BINARY( 001101 )
|
||||
, BOOST_BINARY( 001110 )
|
||||
, BOOST_BINARY( 001111 )
|
||||
, BOOST_BINARY( 010000 )
|
||||
, BOOST_BINARY( 010001 )
|
||||
, BOOST_BINARY( 010010 )
|
||||
, BOOST_BINARY( 010011 )
|
||||
, BOOST_BINARY( 010100 )
|
||||
, BOOST_BINARY( 010101 )
|
||||
, BOOST_BINARY( 010110 )
|
||||
, BOOST_BINARY( 010111 )
|
||||
, BOOST_BINARY( 011000 )
|
||||
, BOOST_BINARY( 011001 )
|
||||
, BOOST_BINARY( 011010 )
|
||||
, BOOST_BINARY( 011011 )
|
||||
, BOOST_BINARY( 011100 )
|
||||
, BOOST_BINARY( 011101 )
|
||||
, BOOST_BINARY( 011110 )
|
||||
, BOOST_BINARY( 011111 )
|
||||
, BOOST_BINARY( 100000 )
|
||||
, BOOST_BINARY( 100001 )
|
||||
, BOOST_BINARY( 100010 )
|
||||
, BOOST_BINARY( 100011 )
|
||||
, BOOST_BINARY( 100100 )
|
||||
, BOOST_BINARY( 100101 )
|
||||
, BOOST_BINARY( 100110 )
|
||||
, BOOST_BINARY( 100111 )
|
||||
, BOOST_BINARY( 101000 )
|
||||
, BOOST_BINARY( 101001 )
|
||||
, BOOST_BINARY( 101010 )
|
||||
, BOOST_BINARY( 101011 )
|
||||
, BOOST_BINARY( 101100 )
|
||||
, BOOST_BINARY( 101101 )
|
||||
, BOOST_BINARY( 101110 )
|
||||
, BOOST_BINARY( 101111 )
|
||||
, BOOST_BINARY( 110000 )
|
||||
, BOOST_BINARY( 110001 )
|
||||
, BOOST_BINARY( 110010 )
|
||||
, BOOST_BINARY( 110011 )
|
||||
, BOOST_BINARY( 110100 )
|
||||
, BOOST_BINARY( 110101 )
|
||||
, BOOST_BINARY( 110110 )
|
||||
, BOOST_BINARY( 110111 )
|
||||
, BOOST_BINARY( 111000 )
|
||||
, BOOST_BINARY( 111001 )
|
||||
, BOOST_BINARY( 111010 )
|
||||
, BOOST_BINARY( 111011 )
|
||||
, BOOST_BINARY( 111100 )
|
||||
, BOOST_BINARY( 111101 )
|
||||
, BOOST_BINARY( 111110 )
|
||||
, BOOST_BINARY( 111111 )
|
||||
};
|
||||
|
||||
unsigned int const unsigned_ints_7_bits[128] =
|
||||
{ BOOST_BINARY( 0000000 )
|
||||
, BOOST_BINARY( 0000001 )
|
||||
, BOOST_BINARY( 0000010 )
|
||||
, BOOST_BINARY( 0000011 )
|
||||
, BOOST_BINARY( 0000100 )
|
||||
, BOOST_BINARY( 0000101 )
|
||||
, BOOST_BINARY( 0000110 )
|
||||
, BOOST_BINARY( 0000111 )
|
||||
, BOOST_BINARY( 0001000 )
|
||||
, BOOST_BINARY( 0001001 )
|
||||
, BOOST_BINARY( 0001010 )
|
||||
, BOOST_BINARY( 0001011 )
|
||||
, BOOST_BINARY( 0001100 )
|
||||
, BOOST_BINARY( 0001101 )
|
||||
, BOOST_BINARY( 0001110 )
|
||||
, BOOST_BINARY( 0001111 )
|
||||
, BOOST_BINARY( 0010000 )
|
||||
, BOOST_BINARY( 0010001 )
|
||||
, BOOST_BINARY( 0010010 )
|
||||
, BOOST_BINARY( 0010011 )
|
||||
, BOOST_BINARY( 0010100 )
|
||||
, BOOST_BINARY( 0010101 )
|
||||
, BOOST_BINARY( 0010110 )
|
||||
, BOOST_BINARY( 0010111 )
|
||||
, BOOST_BINARY( 0011000 )
|
||||
, BOOST_BINARY( 0011001 )
|
||||
, BOOST_BINARY( 0011010 )
|
||||
, BOOST_BINARY( 0011011 )
|
||||
, BOOST_BINARY( 0011100 )
|
||||
, BOOST_BINARY( 0011101 )
|
||||
, BOOST_BINARY( 0011110 )
|
||||
, BOOST_BINARY( 0011111 )
|
||||
, BOOST_BINARY( 0100000 )
|
||||
, BOOST_BINARY( 0100001 )
|
||||
, BOOST_BINARY( 0100010 )
|
||||
, BOOST_BINARY( 0100011 )
|
||||
, BOOST_BINARY( 0100100 )
|
||||
, BOOST_BINARY( 0100101 )
|
||||
, BOOST_BINARY( 0100110 )
|
||||
, BOOST_BINARY( 0100111 )
|
||||
, BOOST_BINARY( 0101000 )
|
||||
, BOOST_BINARY( 0101001 )
|
||||
, BOOST_BINARY( 0101010 )
|
||||
, BOOST_BINARY( 0101011 )
|
||||
, BOOST_BINARY( 0101100 )
|
||||
, BOOST_BINARY( 0101101 )
|
||||
, BOOST_BINARY( 0101110 )
|
||||
, BOOST_BINARY( 0101111 )
|
||||
, BOOST_BINARY( 0110000 )
|
||||
, BOOST_BINARY( 0110001 )
|
||||
, BOOST_BINARY( 0110010 )
|
||||
, BOOST_BINARY( 0110011 )
|
||||
, BOOST_BINARY( 0110100 )
|
||||
, BOOST_BINARY( 0110101 )
|
||||
, BOOST_BINARY( 0110110 )
|
||||
, BOOST_BINARY( 0110111 )
|
||||
, BOOST_BINARY( 0111000 )
|
||||
, BOOST_BINARY( 0111001 )
|
||||
, BOOST_BINARY( 0111010 )
|
||||
, BOOST_BINARY( 0111011 )
|
||||
, BOOST_BINARY( 0111100 )
|
||||
, BOOST_BINARY( 0111101 )
|
||||
, BOOST_BINARY( 0111110 )
|
||||
, BOOST_BINARY( 0111111 )
|
||||
, BOOST_BINARY( 1000000 )
|
||||
, BOOST_BINARY( 1000001 )
|
||||
, BOOST_BINARY( 1000010 )
|
||||
, BOOST_BINARY( 1000011 )
|
||||
, BOOST_BINARY( 1000100 )
|
||||
, BOOST_BINARY( 1000101 )
|
||||
, BOOST_BINARY( 1000110 )
|
||||
, BOOST_BINARY( 1000111 )
|
||||
, BOOST_BINARY( 1001000 )
|
||||
, BOOST_BINARY( 1001001 )
|
||||
, BOOST_BINARY( 1001010 )
|
||||
, BOOST_BINARY( 1001011 )
|
||||
, BOOST_BINARY( 1001100 )
|
||||
, BOOST_BINARY( 1001101 )
|
||||
, BOOST_BINARY( 1001110 )
|
||||
, BOOST_BINARY( 1001111 )
|
||||
, BOOST_BINARY( 1010000 )
|
||||
, BOOST_BINARY( 1010001 )
|
||||
, BOOST_BINARY( 1010010 )
|
||||
, BOOST_BINARY( 1010011 )
|
||||
, BOOST_BINARY( 1010100 )
|
||||
, BOOST_BINARY( 1010101 )
|
||||
, BOOST_BINARY( 1010110 )
|
||||
, BOOST_BINARY( 1010111 )
|
||||
, BOOST_BINARY( 1011000 )
|
||||
, BOOST_BINARY( 1011001 )
|
||||
, BOOST_BINARY( 1011010 )
|
||||
, BOOST_BINARY( 1011011 )
|
||||
, BOOST_BINARY( 1011100 )
|
||||
, BOOST_BINARY( 1011101 )
|
||||
, BOOST_BINARY( 1011110 )
|
||||
, BOOST_BINARY( 1011111 )
|
||||
, BOOST_BINARY( 1100000 )
|
||||
, BOOST_BINARY( 1100001 )
|
||||
, BOOST_BINARY( 1100010 )
|
||||
, BOOST_BINARY( 1100011 )
|
||||
, BOOST_BINARY( 1100100 )
|
||||
, BOOST_BINARY( 1100101 )
|
||||
, BOOST_BINARY( 1100110 )
|
||||
, BOOST_BINARY( 1100111 )
|
||||
, BOOST_BINARY( 1101000 )
|
||||
, BOOST_BINARY( 1101001 )
|
||||
, BOOST_BINARY( 1101010 )
|
||||
, BOOST_BINARY( 1101011 )
|
||||
, BOOST_BINARY( 1101100 )
|
||||
, BOOST_BINARY( 1101101 )
|
||||
, BOOST_BINARY( 1101110 )
|
||||
, BOOST_BINARY( 1101111 )
|
||||
, BOOST_BINARY( 1110000 )
|
||||
, BOOST_BINARY( 1110001 )
|
||||
, BOOST_BINARY( 1110010 )
|
||||
, BOOST_BINARY( 1110011 )
|
||||
, BOOST_BINARY( 1110100 )
|
||||
, BOOST_BINARY( 1110101 )
|
||||
, BOOST_BINARY( 1110110 )
|
||||
, BOOST_BINARY( 1110111 )
|
||||
, BOOST_BINARY( 1111000 )
|
||||
, BOOST_BINARY( 1111001 )
|
||||
, BOOST_BINARY( 1111010 )
|
||||
, BOOST_BINARY( 1111011 )
|
||||
, BOOST_BINARY( 1111100 )
|
||||
, BOOST_BINARY( 1111101 )
|
||||
, BOOST_BINARY( 1111110 )
|
||||
, BOOST_BINARY( 1111111 )
|
||||
};
|
||||
unsigned int const unsigned_ints_8_bits[256] =
|
||||
{ BOOST_BINARY( 00000000 )
|
||||
, BOOST_BINARY( 00000001 )
|
||||
, BOOST_BINARY( 00000010 )
|
||||
, BOOST_BINARY( 00000011 )
|
||||
, BOOST_BINARY( 00000100 )
|
||||
, BOOST_BINARY( 00000101 )
|
||||
, BOOST_BINARY( 00000110 )
|
||||
, BOOST_BINARY( 00000111 )
|
||||
, BOOST_BINARY( 00001000 )
|
||||
, BOOST_BINARY( 00001001 )
|
||||
, BOOST_BINARY( 00001010 )
|
||||
, BOOST_BINARY( 00001011 )
|
||||
, BOOST_BINARY( 00001100 )
|
||||
, BOOST_BINARY( 00001101 )
|
||||
, BOOST_BINARY( 00001110 )
|
||||
, BOOST_BINARY( 00001111 )
|
||||
, BOOST_BINARY( 00010000 )
|
||||
, BOOST_BINARY( 00010001 )
|
||||
, BOOST_BINARY( 00010010 )
|
||||
, BOOST_BINARY( 00010011 )
|
||||
, BOOST_BINARY( 00010100 )
|
||||
, BOOST_BINARY( 00010101 )
|
||||
, BOOST_BINARY( 00010110 )
|
||||
, BOOST_BINARY( 00010111 )
|
||||
, BOOST_BINARY( 00011000 )
|
||||
, BOOST_BINARY( 00011001 )
|
||||
, BOOST_BINARY( 00011010 )
|
||||
, BOOST_BINARY( 00011011 )
|
||||
, BOOST_BINARY( 00011100 )
|
||||
, BOOST_BINARY( 00011101 )
|
||||
, BOOST_BINARY( 00011110 )
|
||||
, BOOST_BINARY( 00011111 )
|
||||
, BOOST_BINARY( 00100000 )
|
||||
, BOOST_BINARY( 00100001 )
|
||||
, BOOST_BINARY( 00100010 )
|
||||
, BOOST_BINARY( 00100011 )
|
||||
, BOOST_BINARY( 00100100 )
|
||||
, BOOST_BINARY( 00100101 )
|
||||
, BOOST_BINARY( 00100110 )
|
||||
, BOOST_BINARY( 00100111 )
|
||||
, BOOST_BINARY( 00101000 )
|
||||
, BOOST_BINARY( 00101001 )
|
||||
, BOOST_BINARY( 00101010 )
|
||||
, BOOST_BINARY( 00101011 )
|
||||
, BOOST_BINARY( 00101100 )
|
||||
, BOOST_BINARY( 00101101 )
|
||||
, BOOST_BINARY( 00101110 )
|
||||
, BOOST_BINARY( 00101111 )
|
||||
, BOOST_BINARY( 00110000 )
|
||||
, BOOST_BINARY( 00110001 )
|
||||
, BOOST_BINARY( 00110010 )
|
||||
, BOOST_BINARY( 00110011 )
|
||||
, BOOST_BINARY( 00110100 )
|
||||
, BOOST_BINARY( 00110101 )
|
||||
, BOOST_BINARY( 00110110 )
|
||||
, BOOST_BINARY( 00110111 )
|
||||
, BOOST_BINARY( 00111000 )
|
||||
, BOOST_BINARY( 00111001 )
|
||||
, BOOST_BINARY( 00111010 )
|
||||
, BOOST_BINARY( 00111011 )
|
||||
, BOOST_BINARY( 00111100 )
|
||||
, BOOST_BINARY( 00111101 )
|
||||
, BOOST_BINARY( 00111110 )
|
||||
, BOOST_BINARY( 00111111 )
|
||||
, BOOST_BINARY( 01000000 )
|
||||
, BOOST_BINARY( 01000001 )
|
||||
, BOOST_BINARY( 01000010 )
|
||||
, BOOST_BINARY( 01000011 )
|
||||
, BOOST_BINARY( 01000100 )
|
||||
, BOOST_BINARY( 01000101 )
|
||||
, BOOST_BINARY( 01000110 )
|
||||
, BOOST_BINARY( 01000111 )
|
||||
, BOOST_BINARY( 01001000 )
|
||||
, BOOST_BINARY( 01001001 )
|
||||
, BOOST_BINARY( 01001010 )
|
||||
, BOOST_BINARY( 01001011 )
|
||||
, BOOST_BINARY( 01001100 )
|
||||
, BOOST_BINARY( 01001101 )
|
||||
, BOOST_BINARY( 01001110 )
|
||||
, BOOST_BINARY( 01001111 )
|
||||
, BOOST_BINARY( 01010000 )
|
||||
, BOOST_BINARY( 01010001 )
|
||||
, BOOST_BINARY( 01010010 )
|
||||
, BOOST_BINARY( 01010011 )
|
||||
, BOOST_BINARY( 01010100 )
|
||||
, BOOST_BINARY( 01010101 )
|
||||
, BOOST_BINARY( 01010110 )
|
||||
, BOOST_BINARY( 01010111 )
|
||||
, BOOST_BINARY( 01011000 )
|
||||
, BOOST_BINARY( 01011001 )
|
||||
, BOOST_BINARY( 01011010 )
|
||||
, BOOST_BINARY( 01011011 )
|
||||
, BOOST_BINARY( 01011100 )
|
||||
, BOOST_BINARY( 01011101 )
|
||||
, BOOST_BINARY( 01011110 )
|
||||
, BOOST_BINARY( 01011111 )
|
||||
, BOOST_BINARY( 01100000 )
|
||||
, BOOST_BINARY( 01100001 )
|
||||
, BOOST_BINARY( 01100010 )
|
||||
, BOOST_BINARY( 01100011 )
|
||||
, BOOST_BINARY( 01100100 )
|
||||
, BOOST_BINARY( 01100101 )
|
||||
, BOOST_BINARY( 01100110 )
|
||||
, BOOST_BINARY( 01100111 )
|
||||
, BOOST_BINARY( 01101000 )
|
||||
, BOOST_BINARY( 01101001 )
|
||||
, BOOST_BINARY( 01101010 )
|
||||
, BOOST_BINARY( 01101011 )
|
||||
, BOOST_BINARY( 01101100 )
|
||||
, BOOST_BINARY( 01101101 )
|
||||
, BOOST_BINARY( 01101110 )
|
||||
, BOOST_BINARY( 01101111 )
|
||||
, BOOST_BINARY( 01110000 )
|
||||
, BOOST_BINARY( 01110001 )
|
||||
, BOOST_BINARY( 01110010 )
|
||||
, BOOST_BINARY( 01110011 )
|
||||
, BOOST_BINARY( 01110100 )
|
||||
, BOOST_BINARY( 01110101 )
|
||||
, BOOST_BINARY( 01110110 )
|
||||
, BOOST_BINARY( 01110111 )
|
||||
, BOOST_BINARY( 01111000 )
|
||||
, BOOST_BINARY( 01111001 )
|
||||
, BOOST_BINARY( 01111010 )
|
||||
, BOOST_BINARY( 01111011 )
|
||||
, BOOST_BINARY( 01111100 )
|
||||
, BOOST_BINARY( 01111101 )
|
||||
, BOOST_BINARY( 01111110 )
|
||||
, BOOST_BINARY( 01111111 )
|
||||
, BOOST_BINARY( 10000000 )
|
||||
, BOOST_BINARY( 10000001 )
|
||||
, BOOST_BINARY( 10000010 )
|
||||
, BOOST_BINARY( 10000011 )
|
||||
, BOOST_BINARY( 10000100 )
|
||||
, BOOST_BINARY( 10000101 )
|
||||
, BOOST_BINARY( 10000110 )
|
||||
, BOOST_BINARY( 10000111 )
|
||||
, BOOST_BINARY( 10001000 )
|
||||
, BOOST_BINARY( 10001001 )
|
||||
, BOOST_BINARY( 10001010 )
|
||||
, BOOST_BINARY( 10001011 )
|
||||
, BOOST_BINARY( 10001100 )
|
||||
, BOOST_BINARY( 10001101 )
|
||||
, BOOST_BINARY( 10001110 )
|
||||
, BOOST_BINARY( 10001111 )
|
||||
, BOOST_BINARY( 10010000 )
|
||||
, BOOST_BINARY( 10010001 )
|
||||
, BOOST_BINARY( 10010010 )
|
||||
, BOOST_BINARY( 10010011 )
|
||||
, BOOST_BINARY( 10010100 )
|
||||
, BOOST_BINARY( 10010101 )
|
||||
, BOOST_BINARY( 10010110 )
|
||||
, BOOST_BINARY( 10010111 )
|
||||
, BOOST_BINARY( 10011000 )
|
||||
, BOOST_BINARY( 10011001 )
|
||||
, BOOST_BINARY( 10011010 )
|
||||
, BOOST_BINARY( 10011011 )
|
||||
, BOOST_BINARY( 10011100 )
|
||||
, BOOST_BINARY( 10011101 )
|
||||
, BOOST_BINARY( 10011110 )
|
||||
, BOOST_BINARY( 10011111 )
|
||||
, BOOST_BINARY( 10100000 )
|
||||
, BOOST_BINARY( 10100001 )
|
||||
, BOOST_BINARY( 10100010 )
|
||||
, BOOST_BINARY( 10100011 )
|
||||
, BOOST_BINARY( 10100100 )
|
||||
, BOOST_BINARY( 10100101 )
|
||||
, BOOST_BINARY( 10100110 )
|
||||
, BOOST_BINARY( 10100111 )
|
||||
, BOOST_BINARY( 10101000 )
|
||||
, BOOST_BINARY( 10101001 )
|
||||
, BOOST_BINARY( 10101010 )
|
||||
, BOOST_BINARY( 10101011 )
|
||||
, BOOST_BINARY( 10101100 )
|
||||
, BOOST_BINARY( 10101101 )
|
||||
, BOOST_BINARY( 10101110 )
|
||||
, BOOST_BINARY( 10101111 )
|
||||
, BOOST_BINARY( 10110000 )
|
||||
, BOOST_BINARY( 10110001 )
|
||||
, BOOST_BINARY( 10110010 )
|
||||
, BOOST_BINARY( 10110011 )
|
||||
, BOOST_BINARY( 10110100 )
|
||||
, BOOST_BINARY( 10110101 )
|
||||
, BOOST_BINARY( 10110110 )
|
||||
, BOOST_BINARY( 10110111 )
|
||||
, BOOST_BINARY( 10111000 )
|
||||
, BOOST_BINARY( 10111001 )
|
||||
, BOOST_BINARY( 10111010 )
|
||||
, BOOST_BINARY( 10111011 )
|
||||
, BOOST_BINARY( 10111100 )
|
||||
, BOOST_BINARY( 10111101 )
|
||||
, BOOST_BINARY( 10111110 )
|
||||
, BOOST_BINARY( 10111111 )
|
||||
, BOOST_BINARY( 11000000 )
|
||||
, BOOST_BINARY( 11000001 )
|
||||
, BOOST_BINARY( 11000010 )
|
||||
, BOOST_BINARY( 11000011 )
|
||||
, BOOST_BINARY( 11000100 )
|
||||
, BOOST_BINARY( 11000101 )
|
||||
, BOOST_BINARY( 11000110 )
|
||||
, BOOST_BINARY( 11000111 )
|
||||
, BOOST_BINARY( 11001000 )
|
||||
, BOOST_BINARY( 11001001 )
|
||||
, BOOST_BINARY( 11001010 )
|
||||
, BOOST_BINARY( 11001011 )
|
||||
, BOOST_BINARY( 11001100 )
|
||||
, BOOST_BINARY( 11001101 )
|
||||
, BOOST_BINARY( 11001110 )
|
||||
, BOOST_BINARY( 11001111 )
|
||||
, BOOST_BINARY( 11010000 )
|
||||
, BOOST_BINARY( 11010001 )
|
||||
, BOOST_BINARY( 11010010 )
|
||||
, BOOST_BINARY( 11010011 )
|
||||
, BOOST_BINARY( 11010100 )
|
||||
, BOOST_BINARY( 11010101 )
|
||||
, BOOST_BINARY( 11010110 )
|
||||
, BOOST_BINARY( 11010111 )
|
||||
, BOOST_BINARY( 11011000 )
|
||||
, BOOST_BINARY( 11011001 )
|
||||
, BOOST_BINARY( 11011010 )
|
||||
, BOOST_BINARY( 11011011 )
|
||||
, BOOST_BINARY( 11011100 )
|
||||
, BOOST_BINARY( 11011101 )
|
||||
, BOOST_BINARY( 11011110 )
|
||||
, BOOST_BINARY( 11011111 )
|
||||
, BOOST_BINARY( 11100000 )
|
||||
, BOOST_BINARY( 11100001 )
|
||||
, BOOST_BINARY( 11100010 )
|
||||
, BOOST_BINARY( 11100011 )
|
||||
, BOOST_BINARY( 11100100 )
|
||||
, BOOST_BINARY( 11100101 )
|
||||
, BOOST_BINARY( 11100110 )
|
||||
, BOOST_BINARY( 11100111 )
|
||||
, BOOST_BINARY( 11101000 )
|
||||
, BOOST_BINARY( 11101001 )
|
||||
, BOOST_BINARY( 11101010 )
|
||||
, BOOST_BINARY( 11101011 )
|
||||
, BOOST_BINARY( 11101100 )
|
||||
, BOOST_BINARY( 11101101 )
|
||||
, BOOST_BINARY( 11101110 )
|
||||
, BOOST_BINARY( 11101111 )
|
||||
, BOOST_BINARY( 11110000 )
|
||||
, BOOST_BINARY( 11110001 )
|
||||
, BOOST_BINARY( 11110010 )
|
||||
, BOOST_BINARY( 11110011 )
|
||||
, BOOST_BINARY( 11110100 )
|
||||
, BOOST_BINARY( 11110101 )
|
||||
, BOOST_BINARY( 11110110 )
|
||||
, BOOST_BINARY( 11110111 )
|
||||
, BOOST_BINARY( 11111000 )
|
||||
, BOOST_BINARY( 11111001 )
|
||||
, BOOST_BINARY( 11111010 )
|
||||
, BOOST_BINARY( 11111011 )
|
||||
, BOOST_BINARY( 11111100 )
|
||||
, BOOST_BINARY( 11111101 )
|
||||
, BOOST_BINARY( 11111110 )
|
||||
, BOOST_BINARY( 11111111 )
|
||||
};
|
||||
|
||||
struct left_is_not_one_less_than_right
|
||||
{
|
||||
bool operator ()( unsigned int left, unsigned int right ) const
|
||||
{
|
||||
return right != left + 1;
|
||||
}
|
||||
};
|
||||
|
||||
template< std::size_t Size >
|
||||
bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
|
||||
{
|
||||
unsigned int const* const curr = array,
|
||||
* const end = array + Size;
|
||||
|
||||
return ( *curr == 0 )
|
||||
&& ( std::adjacent_find( curr, end
|
||||
, left_is_not_one_less_than_right()
|
||||
)
|
||||
== end
|
||||
);
|
||||
}
|
||||
|
||||
std::size_t const unsigned_int_id = 1,
|
||||
unsigned_long_int_id = 2;
|
||||
|
||||
typedef char (&unsigned_int_id_type)[unsigned_int_id];
|
||||
typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
|
||||
|
||||
// Note: Functions only used for type checking
|
||||
unsigned_int_id_type binary_type_checker( unsigned int );
|
||||
unsigned_long_int_id_type binary_type_checker( unsigned long int );
|
||||
|
||||
int test_main( int, char *[] )
|
||||
{
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
|
||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
|
||||
|
||||
BOOST_CHECK( std::equal( &random_unsigned_ints_hex[0]
|
||||
, random_unsigned_ints_hex + num_random_test_values
|
||||
, &random_unsigned_ints_binary[0]
|
||||
)
|
||||
);
|
||||
|
||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
|
||||
== unsigned_int_id
|
||||
);
|
||||
|
||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
|
||||
== unsigned_long_int_id
|
||||
);
|
||||
|
||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
|
||||
== unsigned_long_int_id
|
||||
);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
#
|
||||
# Copyright Troy D. Straszheim
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See http://www.boost.org/LICENSE_1_0.txt
|
||||
#
|
||||
foreach(T
|
||||
constructors
|
||||
dummy_arg_disambiguation
|
||||
lazy
|
||||
lazy_test
|
||||
member_templates
|
||||
namespace_disambiguation
|
||||
no_disambiguation
|
||||
partial_specializations
|
||||
)
|
||||
boost_test_run(${T} DEPENDS boost_test_exec_monitor)
|
||||
endforeach()
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -146,7 +146,7 @@ int main()
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
"http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
|
||||
@@ -99,7 +99,7 @@ directly to the container:</p>
|
||||
<H2><A NAME="framework"></A>Framework</H2>
|
||||
<p>
|
||||
This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
|
||||
the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible
|
||||
the entire set of constructor overloads ftom the contained type. It also allows the container to remove the CopyConstuctible
|
||||
requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
|
||||
The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
|
||||
Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
|
||||
@@ -117,7 +117,7 @@ The following simplified example shows the basic idea. A complete example follow
|
||||
<pre>struct C
|
||||
{
|
||||
template<class InPlaceFactory>
|
||||
C ( InPlaceFactory const& aFactory )
|
||||
C ( InPlaceFactory const& aFactoty )
|
||||
:
|
||||
contained_ ( uninitialized_storage() )
|
||||
{
|
||||
@@ -293,4 +293,4 @@ the latest version of this file can be found at <A
|
||||
HREF="http://www.boost.org">www.boost.org</A>, and the boost
|
||||
<A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
|
||||
</BODY>
|
||||
</HTML>
|
||||
</HTML>
|
||||
@@ -92,7 +92,7 @@ struct call_traits<T&>
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
|
||||
#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 )
|
||||
#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x581 ) )
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
|
||||
@@ -6,8 +6,8 @@
|
||||
#ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
|
||||
#define UUID_1D94A7C6054E11DB9804B622A1EF5492
|
||||
|
||||
//The header <boost/exception.hpp> has been deprecated.
|
||||
//Please #include <boost/exception/all.hpp> instead.
|
||||
#include <boost/exception/all.hpp>
|
||||
#include <boost/exception/info_tuple.hpp>
|
||||
#include <boost/exception_ptr.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#endif
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
// See http://www.boost.org/libs/utility/operators.htm for documentation.
|
||||
|
||||
// Revision History
|
||||
// 07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
|
||||
// 03 Apr 08 Make sure "convertible to bool" is sufficient
|
||||
// for T::operator<, etc. (Daniel Frey)
|
||||
// 24 May 07 Changed empty_base to depend on T, see
|
||||
@@ -583,35 +582,7 @@ struct ordered_euclidian_ring_operators1
|
||||
: totally_ordered1<T
|
||||
, euclidian_ring_operators1<T, B
|
||||
> > {};
|
||||
|
||||
template <class T, class U, class B = ::boost::detail::empty_base<T> >
|
||||
struct euclidean_ring_operators2
|
||||
: ring_operators2<T, U
|
||||
, dividable2<T, U
|
||||
, dividable2_left<T, U
|
||||
, modable2<T, U
|
||||
, modable2_left<T, U, B
|
||||
> > > > > {};
|
||||
|
||||
template <class T, class B = ::boost::detail::empty_base<T> >
|
||||
struct euclidean_ring_operators1
|
||||
: ring_operators1<T
|
||||
, dividable1<T
|
||||
, modable1<T, B
|
||||
> > > {};
|
||||
|
||||
template <class T, class U, class B = ::boost::detail::empty_base<T> >
|
||||
struct ordered_euclidean_ring_operators2
|
||||
: totally_ordered2<T, U
|
||||
, euclidean_ring_operators2<T, U, B
|
||||
> > {};
|
||||
|
||||
template <class T, class B = ::boost::detail::empty_base<T> >
|
||||
struct ordered_euclidean_ring_operators1
|
||||
: totally_ordered1<T
|
||||
, euclidean_ring_operators1<T, B
|
||||
> > {};
|
||||
|
||||
|
||||
template <class T, class P, class B = ::boost::detail::empty_base<T> >
|
||||
struct input_iteratable
|
||||
: equality_comparable1<T
|
||||
@@ -868,8 +839,6 @@ BOOST_OPERATOR_TEMPLATE(field_operators)
|
||||
BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
|
||||
BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
|
||||
BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
|
||||
BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
|
||||
BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
|
||||
BOOST_OPERATOR_TEMPLATE2(input_iteratable)
|
||||
BOOST_OPERATOR_TEMPLATE1(output_iteratable)
|
||||
BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
//
|
||||
// ref.hpp - ref/cref, useful helper functions
|
||||
//
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001, 2002 Peter Dimov
|
||||
// Copyright (C) 2002 David Abrahams
|
||||
//
|
||||
@@ -173,17 +173,6 @@ class unwrap_reference
|
||||
|
||||
# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template <class T> inline typename unwrap_reference<T>::type&
|
||||
unwrap_ref(T& t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
|
||||
{
|
||||
return r.get_pointer();
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_REF_HPP_INCLUDED
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
// Copyright (C) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_SWAP_HPP
|
||||
#define BOOST_SWAP_HPP
|
||||
|
||||
#include "boost/utility/swap.hpp"
|
||||
|
||||
#endif
|
||||
@@ -10,8 +10,7 @@
|
||||
#define BOOST_UTILITY_HPP
|
||||
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/utility/base_from_member.hpp>
|
||||
#include <boost/utility/binary.hpp>
|
||||
#include <boost/utility/base_from_member.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/checked_delete.hpp>
|
||||
#include <boost/next_prior.hpp>
|
||||
|
||||
@@ -21,17 +21,6 @@ namespace boost
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template<class T> struct addr_impl_ref
|
||||
{
|
||||
T & v_;
|
||||
|
||||
inline addr_impl_ref( T & v ): v_( v ) {}
|
||||
inline operator T& () const { return v_; }
|
||||
|
||||
private:
|
||||
addr_impl_ref & operator=(const addr_impl_ref &);
|
||||
};
|
||||
|
||||
template<class T> struct addressof_impl
|
||||
{
|
||||
static inline T * f( T & v, long )
|
||||
@@ -50,40 +39,12 @@ template<class T> struct addressof_impl
|
||||
|
||||
template<class T> T * addressof( T & v )
|
||||
{
|
||||
#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
|
||||
|
||||
return boost::detail::addressof_impl<T>::f( v, 0 );
|
||||
|
||||
#else
|
||||
|
||||
return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template<class T> struct addressof_addp
|
||||
{
|
||||
typedef T * type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template< class T, std::size_t N >
|
||||
typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
|
||||
{
|
||||
return &t;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// Borland doesn't like casting an array reference to a char reference
|
||||
// but these overloads work around the problem.
|
||||
#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
template<typename T,std::size_t N>
|
||||
T (*addressof(T (&t)[N]))[N]
|
||||
{
|
||||
@@ -95,7 +56,7 @@ const T (*addressof(const T (&t)[N]))[N]
|
||||
{
|
||||
return reinterpret_cast<const T(*)[N]>(&t);
|
||||
}
|
||||
#endif
|
||||
# endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
||||
@@ -1,708 +0,0 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2005 Matthew Calabrese
|
||||
|
||||
Use, modification and distribution is subject to 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)
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef BOOST_UTILITY_BINARY_HPP
|
||||
#define BOOST_UTILITY_BINARY_HPP
|
||||
|
||||
/*=============================================================================
|
||||
|
||||
Binary Literal Utility
|
||||
______________________
|
||||
|
||||
|
||||
The following code works by converting the input bit pattern into a
|
||||
Boost.Preprocessor sequence, then converting groupings of 3 bits each into
|
||||
the corresponding octal digit, and finally concatenating all of the digits
|
||||
together along with a leading zero. This yields a standard octal literal
|
||||
with the desired value as specified in bits.
|
||||
|
||||
==============================================================================*/
|
||||
|
||||
#include <boost/preprocessor/control/deduce_d.hpp>
|
||||
#include <boost/preprocessor/facilities/identity.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/seq/cat.hpp>
|
||||
#include <boost/preprocessor/seq/transform.hpp>
|
||||
#include <boost/preprocessor/arithmetic/mod.hpp>
|
||||
#include <boost/preprocessor/seq/size.hpp>
|
||||
#include <boost/preprocessor/facilities/empty.hpp>
|
||||
#include <boost/preprocessor/control/while.hpp>
|
||||
|
||||
#define BOOST_BINARY( bit_groupings ) \
|
||||
BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings )
|
||||
|
||||
#define BOOST_BINARY_U( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U )
|
||||
|
||||
#define BOOST_BINARY_L( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L )
|
||||
|
||||
#define BOOST_BINARY_UL( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL )
|
||||
|
||||
#define BOOST_BINARY_LU( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU )
|
||||
|
||||
#define BOOST_BINARY_LL( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL )
|
||||
|
||||
#define BOOST_BINARY_ULL( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL )
|
||||
|
||||
#define BOOST_BINARY_LLU( bit_groupings ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU )
|
||||
|
||||
#define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix ) \
|
||||
BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix )
|
||||
|
||||
#define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix ) \
|
||||
BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix )
|
||||
|
||||
#define BOOST_BINARY_LITERAL_D( d, bit_groupings ) \
|
||||
BOOST_PP_SEQ_CAT \
|
||||
( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
|
||||
)
|
||||
|
||||
#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
|
||||
BOOST_PP_SEQ_TRANSFORM \
|
||||
( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION \
|
||||
, BOOST_PP_NIL \
|
||||
, BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
|
||||
( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE \
|
||||
( \
|
||||
d \
|
||||
, BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
|
||||
) \
|
||||
) \
|
||||
)
|
||||
|
||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence ) \
|
||||
BOOST_PP_CAT \
|
||||
( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence \
|
||||
, END_BIT \
|
||||
)
|
||||
|
||||
#define BOOST_DETAIL_BITS_PER_OCTIT 3
|
||||
|
||||
#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
|
||||
BOOST_PP_CAT \
|
||||
( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_ \
|
||||
, BOOST_PP_MOD_D( d \
|
||||
, BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence ) \
|
||||
, BOOST_DETAIL_BITS_PER_OCTIT \
|
||||
) \
|
||||
) \
|
||||
incomplete_nibble_sequence
|
||||
|
||||
#define BOOST_DETAIL_FIXED_COMPL( bit ) \
|
||||
BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
|
||||
|
||||
#define BOOST_DETAIL_FIXED_COMPL_0 1
|
||||
|
||||
#define BOOST_DETAIL_FIXED_COMPL_1 0
|
||||
|
||||
#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
|
||||
BOOST_PP_EMPTY \
|
||||
BOOST_PP_CAT( BOOST_PP_WHILE_, d ) \
|
||||
( BOOST_DETAIL_BINARY_LITERAL_PREDICATE \
|
||||
, BOOST_DETAIL_BINARY_LITERAL_OPERATION \
|
||||
, bit_groupings () \
|
||||
)
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state ) \
|
||||
BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) )
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state ) \
|
||||
BOOST_DETAIL_SPLIT_AND_SWAP \
|
||||
( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) )
|
||||
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple ) \
|
||||
BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple
|
||||
|
||||
#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 ) \
|
||||
BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0
|
||||
|
||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
|
||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
|
||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0
|
||||
|
||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT
|
||||
|
||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit ) \
|
||||
( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2
|
||||
|
||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit ) \
|
||||
bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3
|
||||
|
||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit ) \
|
||||
bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1
|
||||
|
||||
#define BOOST_DETAIL_SPLIT_AND_SWAP( params ) \
|
||||
BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
|
||||
|
||||
#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param ) \
|
||||
second_param first_param
|
||||
|
||||
#define BOOST_DETAIL_LEFT_OF_COMMA( params ) \
|
||||
BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params )
|
||||
|
||||
#define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param ) \
|
||||
first_param
|
||||
|
||||
/* Begin derived concepts from Chaos by Paul Mensonides */
|
||||
|
||||
#define BOOST_DETAIL_IS_NULLARY_ARGS( param ) \
|
||||
BOOST_DETAIL_LEFT_OF_COMMA \
|
||||
( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_ \
|
||||
, BOOST_DETAIL_IS_NULLARY_ARGS_C param \
|
||||
) \
|
||||
)
|
||||
|
||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_C() \
|
||||
1
|
||||
|
||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1 \
|
||||
1, BOOST_PP_NIL
|
||||
|
||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C \
|
||||
0, BOOST_PP_NIL
|
||||
|
||||
/* End derived concepts from Chaos by Paul Mensonides */
|
||||
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6
|
||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1),
|
||||
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0),
|
||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1),
|
||||
|
||||
#endif
|
||||
@@ -10,6 +10,46 @@
|
||||
# error Boost result_of - do not include this file!
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_DECLTYPE)
|
||||
|
||||
// As of N2588, C++0x result_of only supports function call
|
||||
// expressions of the form f(x). This precludes support for member
|
||||
// function pointers, which are invoked with expressions of the form
|
||||
// o->*f(x). This implementation supports both.
|
||||
template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
|
||||
BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
||||
struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
|
||||
: mpl::if_<
|
||||
mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
|
||||
, detail::result_of_impl<
|
||||
F, F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
|
||||
>
|
||||
, detail::result_of_decltype_impl<
|
||||
F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
|
||||
>
|
||||
>::type
|
||||
{};
|
||||
|
||||
namespace detail {
|
||||
|
||||
# define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
|
||||
static T ## n t ## n; \
|
||||
/**/
|
||||
|
||||
template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
|
||||
BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
||||
class result_of_decltype_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
|
||||
{
|
||||
static F f;
|
||||
BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
|
||||
public:
|
||||
typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
#else // defined(BOOST_HAS_DECLTYPE)
|
||||
|
||||
// CWPro8 requires an argument in a function type specialization
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
|
||||
# define BOOST_RESULT_OF_ARGS void
|
||||
@@ -26,6 +66,8 @@ struct result_of<F(BOOST_RESULT_OF_ARGS)>
|
||||
|
||||
#undef BOOST_RESULT_OF_ARGS
|
||||
|
||||
#endif // defined(BOOST_HAS_DECLTYPE)
|
||||
|
||||
#if BOOST_PP_ITERATION() >= 1
|
||||
|
||||
namespace detail {
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
|
||||
// Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
|
||||
// Jeremiah Willcock (jewillco at osl.iu.edu)
|
||||
// Andrew Lumsdaine (lums at osl.iu.edu)
|
||||
|
||||
|
||||
@@ -10,13 +10,17 @@
|
||||
#define BOOST_RESULT_OF_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/type_traits/ice.hpp>
|
||||
#include <boost/type.hpp>
|
||||
#include <boost/preprocessor.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_member_function_pointer.hpp>
|
||||
|
||||
#ifndef BOOST_RESULT_OF_NUM_ARGS
|
||||
# define BOOST_RESULT_OF_NUM_ARGS 10
|
||||
@@ -32,6 +36,7 @@ namespace detail {
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
|
||||
|
||||
template<typename F, typename FArgs, bool HasResultType> struct result_of_impl;
|
||||
template<typename F> struct result_of_decltype_impl;
|
||||
|
||||
template<typename F>
|
||||
struct result_of_void_impl
|
||||
@@ -70,8 +75,8 @@ struct result_of_nested_result : F::template result<FArgs>
|
||||
template<typename F, typename FArgs>
|
||||
struct result_of_impl<F, FArgs, false>
|
||||
: mpl::if_<is_function_with_no_args<FArgs>,
|
||||
result_of_void_impl<F>,
|
||||
result_of_nested_result<F, FArgs> >::type
|
||||
result_of_void_impl<F>,
|
||||
result_of_nested_result<F, FArgs> >::type
|
||||
{};
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
|
||||
#ifndef BOOST_UTILITY_SWAP_HPP
|
||||
#define BOOST_UTILITY_SWAP_HPP
|
||||
|
||||
// Note: the implementation of this utility contains various workarounds:
|
||||
// - swap_impl is put outside the boost namespace, to avoid infinite
|
||||
// recursion (causing stack overflow) when swapping objects of a primitive
|
||||
// type.
|
||||
// - swap_impl has a using-directive, rather than a using-declaration,
|
||||
// because some compilers (including MSVC 7.1, Borland 5.9.3, and
|
||||
// Intel 8.1) don't do argument-dependent lookup when it has a
|
||||
// using-declaration instead.
|
||||
// - boost::swap has two template arguments, instead of one, to
|
||||
// avoid ambiguity when swapping objects of a Boost type that does
|
||||
// not have its own boost::swap overload.
|
||||
|
||||
#include <algorithm> //for std::swap
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
namespace boost_swap_impl
|
||||
{
|
||||
template<class T>
|
||||
void swap_impl(T& left, T& right)
|
||||
{
|
||||
using namespace std;//use std::swap if argument dependent lookup fails
|
||||
swap(left,right);
|
||||
}
|
||||
|
||||
template<class T, std::size_t N>
|
||||
void swap_impl(T (& left)[N], T (& right)[N])
|
||||
{
|
||||
for (std::size_t i = 0; i < N; ++i)
|
||||
{
|
||||
::boost_swap_impl::swap_impl(left[i], right[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<class T1, class T2>
|
||||
void swap(T1& left, T2& right)
|
||||
{
|
||||
::boost_swap_impl::swap_impl(left, right);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -7,7 +7,6 @@
|
||||
// 21 Ago 2002 (Created) Fernando Cacciola
|
||||
// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
|
||||
// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
|
||||
// 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
|
||||
//
|
||||
#ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
|
||||
#define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
|
||||
@@ -23,7 +22,6 @@
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
#include <boost/swap.hpp>
|
||||
#include <cstring>
|
||||
#include <new>
|
||||
|
||||
@@ -95,11 +93,6 @@ class value_initialized
|
||||
return wrapper_address()->data;
|
||||
}
|
||||
|
||||
void swap(value_initialized & arg)
|
||||
{
|
||||
::boost::swap( this->data(), arg.data() );
|
||||
}
|
||||
|
||||
operator T&() const { return this->data(); }
|
||||
|
||||
} ;
|
||||
@@ -117,12 +110,6 @@ T& get ( value_initialized<T>& x )
|
||||
return x.data() ;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
|
||||
{
|
||||
lhs.swap(rhs) ;
|
||||
}
|
||||
|
||||
|
||||
class initialized_value_t
|
||||
{
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
<a href="value_init.htm">value_init</a></p>
|
||||
</blockquote>
|
||||
<hr>
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file <a href="../../LICENSE_1_0.txt">
|
||||
LICENSE_1_0.txt</a> or copy at
|
||||
|
||||
@@ -1 +0,0 @@
|
||||
boost_module(utility DEPENDS iterator exception detail )
|
||||
@@ -132,18 +132,18 @@
|
||||
class MyInt
|
||||
: boost::operators<MyInt>
|
||||
{
|
||||
bool operator<(const MyInt& x) const;
|
||||
bool operator<(const MyInt& x) const;
|
||||
bool operator==(const MyInt& x) const;
|
||||
MyInt& operator+=(const MyInt& x);
|
||||
MyInt& operator-=(const MyInt& x);
|
||||
MyInt& operator*=(const MyInt& x);
|
||||
MyInt& operator/=(const MyInt& x);
|
||||
MyInt& operator%=(const MyInt& x);
|
||||
MyInt& operator|=(const MyInt& x);
|
||||
MyInt& operator&=(const MyInt& x);
|
||||
MyInt& operator^=(const MyInt& x);
|
||||
MyInt& operator++();
|
||||
MyInt& operator--();
|
||||
MyInt& operator+=(const MyInt& x);
|
||||
MyInt& operator-=(const MyInt& x);
|
||||
MyInt& operator*=(const MyInt& x);
|
||||
MyInt& operator/=(const MyInt& x);
|
||||
MyInt& operator%=(const MyInt& x);
|
||||
MyInt& operator|=(const MyInt& x);
|
||||
MyInt& operator&=(const MyInt& x);
|
||||
MyInt& operator^=(const MyInt& x);
|
||||
MyInt& operator++();
|
||||
MyInt& operator--();
|
||||
};
|
||||
</pre>
|
||||
</blockquote>
|
||||
@@ -345,7 +345,7 @@ class MyInt
|
||||
</ul>
|
||||
|
||||
<p>As Daniel Krügler pointed out, this technique violates 14.6.5/2
|
||||
and is thus non-portable. The reasoning is, that the operators injected
|
||||
and is thus non-portable. The reasoning is, that the operators injected
|
||||
by the instantiation of e.g.
|
||||
<code>less_than_comparable<myclass></code> can not be found
|
||||
by ADL according to the rules given by 3.4.2/2, since myclass is
|
||||
@@ -445,9 +445,6 @@ const point<float> pi_over_4_normalized = pi_over_4 / length(pi_over_4);
|
||||
optional template parameter <code>B</code>, which is not shown, for the
|
||||
<a href="#chaining">base class chaining</a> technique.</p>
|
||||
|
||||
<p>The primary operand type <code>T</code> needs to be of class type,
|
||||
built-in types are not supported.</p>
|
||||
|
||||
<table cellpadding="5" border="1" align="center">
|
||||
<caption>
|
||||
Simple Arithmetic Operator Template Classes
|
||||
@@ -920,7 +917,7 @@ T operator+( const T& lhs, const T& rhs )
|
||||
created, <code>operator+=</code> is called on it and it is copied to the
|
||||
function return value (which is another unnamed object of type
|
||||
<code>T</code>). The standard doesn't generally allow the intermediate
|
||||
object to be optimized away:
|
||||
object to be optimized away:
|
||||
|
||||
<blockquote>
|
||||
3.7.2/2: Automatic storage duration<br>
|
||||
@@ -931,7 +928,7 @@ T operator+( const T& lhs, const T& rhs )
|
||||
unused, except that a class object or its copy may be eliminated as
|
||||
specified in 12.8.
|
||||
</blockquote>
|
||||
The reference to 12.8 is important for us:
|
||||
The reference to 12.8 is important for us:
|
||||
|
||||
<blockquote>
|
||||
12.8/15: Copying class objects<br>
|
||||
@@ -945,7 +942,7 @@ T operator+( const T& lhs, const T& rhs )
|
||||
</blockquote>
|
||||
This optimization is known as the named return value optimization (NRVO),
|
||||
which leads us to the following implementation for
|
||||
<code>operator+</code>:
|
||||
<code>operator+</code>:
|
||||
<pre>
|
||||
T operator+( const T& lhs, const T& rhs )
|
||||
{
|
||||
@@ -959,7 +956,7 @@ T operator+( const T& lhs, const T& rhs )
|
||||
even implement it in an incorrect way which makes it useless here.
|
||||
Without the NRVO, the NRVO-friendly code is no worse than the original
|
||||
code showed above, but there is another possible implementation, which
|
||||
has some very special properties:
|
||||
has some very special properties:
|
||||
<pre>
|
||||
T operator+( T lhs, const T& rhs )
|
||||
{
|
||||
@@ -985,7 +982,7 @@ T operator+( T lhs, const T& rhs )
|
||||
will force the NRVO-friendly implementation to be used even for compilers
|
||||
that don't implement the NRVO. <br>
|
||||
<br>
|
||||
|
||||
|
||||
<h3><a name="grpd_oprs">Grouped Arithmetic Operators</a></h3>
|
||||
|
||||
<p>The following templates provide common groups of related operations.
|
||||
@@ -1423,9 +1420,9 @@ T operator+( T lhs, const T& rhs )
|
||||
|
||||
<tr>
|
||||
<td><code><a name=
|
||||
"euclidean_ring_operators1">euclidean_ring_operators<T></a></code><br>
|
||||
"euclidian_ring_operators1">euclidian_ring_operators<T></a></code><br>
|
||||
|
||||
<code>euclidean_ring_operators1<T></code></td>
|
||||
<code>euclidian_ring_operators1<T></code></td>
|
||||
|
||||
<td>
|
||||
<ul>
|
||||
@@ -1442,9 +1439,9 @@ T operator+( T lhs, const T& rhs )
|
||||
|
||||
<tr>
|
||||
<td><code><a name=
|
||||
"euclidean_ring_operators2">euclidean_ring_operators<T,
|
||||
"euclidian_ring_operators2">euclidian_ring_operators<T,
|
||||
U></a></code><br>
|
||||
<code>euclidean_ring_operators2<T, U></code></td>
|
||||
<code>euclidian_ring_operators2<T, U></code></td>
|
||||
|
||||
<td>
|
||||
<ul>
|
||||
@@ -1467,14 +1464,14 @@ T operator+( T lhs, const T& rhs )
|
||||
|
||||
<tr>
|
||||
<td><code><a name=
|
||||
"ordered_euclidean_ring_operators1">ordered_euclidean_ring_operators<T></a></code><br>
|
||||
"ordered_euclidian_ring_operators1">ordered_euclidian_ring_operators<T></a></code><br>
|
||||
|
||||
<code>ordered_euclidean_ring_operators1<T></code></td>
|
||||
<code>ordered_euclidian_ring_operators1<T></code></td>
|
||||
|
||||
<td>
|
||||
<ul>
|
||||
<li><code><a href=
|
||||
"#euclidean_ring_operators1">euclidean_ring_operators<T></a></code></li>
|
||||
"#euclidian_ring_operators1">euclidian_ring_operators<T></a></code></li>
|
||||
|
||||
<li><code><a href=
|
||||
"#totally_ordered1">totally_ordered<T></a></code></li>
|
||||
@@ -1484,14 +1481,14 @@ T operator+( T lhs, const T& rhs )
|
||||
|
||||
<tr>
|
||||
<td><code><a name=
|
||||
"ordered_euclidean_ring_operators2">ordered_euclidean_ring_operators<T,
|
||||
"ordered_euclidian_ring_operators2">ordered_euclidian_ring_operators<T,
|
||||
U></a></code><br>
|
||||
<code>ordered_euclidean_ring_operators2<T, U></code></td>
|
||||
<code>ordered_euclidian_ring_operators2<T, U></code></td>
|
||||
|
||||
<td>
|
||||
<ul>
|
||||
<li><code><a href=
|
||||
"#euclidean_ring_operators2">euclidean_ring_operators<T,
|
||||
"#euclidian_ring_operators2">euclidian_ring_operators<T,
|
||||
U></a></code></li>
|
||||
|
||||
<li><code><a href="#totally_ordered2">totally_ordered<T,
|
||||
@@ -1501,15 +1498,6 @@ T operator+( T lhs, const T& rhs )
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h4>Spelling: euclidean vs. euclidian</h4>
|
||||
|
||||
<p>Older versions of the Boost.Operators library used
|
||||
"<code>euclidian</code>", but it was pointed out that
|
||||
"<code>euclidean</code>" is the more common spelling.
|
||||
To be compatible with older version, the library now supports
|
||||
both spellings.
|
||||
</p>
|
||||
|
||||
<h3><a name="ex_oprs">Example</a> Templates</h3>
|
||||
|
||||
<p>The arithmetic operator class templates <code><a href=
|
||||
@@ -1588,8 +1576,9 @@ T operator+( T lhs, const T& rhs )
|
||||
|
||||
<p>The <cite><a href="operators_test.cpp">operators_test.cpp</a></cite>
|
||||
program demonstrates the use of the arithmetic operator templates, and
|
||||
can also be used to verify correct operation. Check the compiler status
|
||||
report for the test results with selected platforms.</p>
|
||||
can also be used to verify correct operation. Check the <a href=
|
||||
"../../status/compiler_status.html">compiler status report</a> for the
|
||||
test results with selected platforms.</p>
|
||||
|
||||
<h2><a name="deref">Dereference</a> Operators and Iterator Helpers</h2>
|
||||
|
||||
@@ -1867,7 +1856,7 @@ T operator+( T lhs, const T& rhs )
|
||||
V, D, P, R></a></code></td>
|
||||
|
||||
<td>
|
||||
Supports the operations and has the requirements of
|
||||
Supports the operations and has the requirements of
|
||||
|
||||
<ul>
|
||||
<li><code><a href="#input_iteratable">input_iteratable<T,
|
||||
@@ -1881,7 +1870,7 @@ T operator+( T lhs, const T& rhs )
|
||||
"output_iterator_helper">output_iterator_helper<T></a></code></td>
|
||||
|
||||
<td>
|
||||
Supports the operations and has the requirements of
|
||||
Supports the operations and has the requirements of
|
||||
|
||||
<ul>
|
||||
<li><code><a href=
|
||||
@@ -1897,7 +1886,7 @@ T operator+( T lhs, const T& rhs )
|
||||
R></a></code></td>
|
||||
|
||||
<td>
|
||||
Supports the operations and has the requirements of
|
||||
Supports the operations and has the requirements of
|
||||
|
||||
<ul>
|
||||
<li><code><a href="#forward_iteratable">forward_iteratable<T,
|
||||
@@ -1912,7 +1901,7 @@ T operator+( T lhs, const T& rhs )
|
||||
V, D, P, R></a></code></td>
|
||||
|
||||
<td>
|
||||
Supports the operations and has the requirements of
|
||||
Supports the operations and has the requirements of
|
||||
|
||||
<ul>
|
||||
<li><code><a href=
|
||||
@@ -1928,7 +1917,7 @@ T operator+( T lhs, const T& rhs )
|
||||
V, D, P, R></a></code></td>
|
||||
|
||||
<td>
|
||||
Supports the operations and has the requirements of
|
||||
Supports the operations and has the requirements of
|
||||
|
||||
<ul>
|
||||
<li><code><a href=
|
||||
@@ -1979,8 +1968,8 @@ struct function_output_iterator
|
||||
template<typename T>
|
||||
function_output_iterator& operator=(T const& value)
|
||||
{
|
||||
this->func(value);
|
||||
return *this;
|
||||
this->func(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
@@ -2033,7 +2022,7 @@ public:
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<p>Check the <a href="http://www.boost.org/development/testing.html">compiler status
|
||||
<p>Check the <a href="../../status/compiler_status.html">compiler status
|
||||
report</a> for the test results with selected platforms.</p>
|
||||
<hr>
|
||||
|
||||
@@ -2130,11 +2119,11 @@ public:
|
||||
backward-compatible.</p>
|
||||
<hr>
|
||||
|
||||
<p>Revised: 7 Aug 2008</p>
|
||||
<p>Revised: 29 Oct 2004</p>
|
||||
|
||||
<p>Copyright © Beman Dawes, David Abrahams, 1999-2001.</p>
|
||||
<p>Copyright © Daniel Frey, 2002-2009.</p>
|
||||
<p>Use, modification, and distribution is subject to the Boost Software
|
||||
<p>Copyright © Daniel Frey, 2002-2004.</p>
|
||||
<p>Use, modification, and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file
|
||||
<a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
|
||||
<a href="http://www.boost.org/LICENSE_1_0.txt">
|
||||
|
||||
@@ -258,8 +258,8 @@ namespace
|
||||
// U must be convertible to T
|
||||
template <class T, class U>
|
||||
class Wrapped6
|
||||
: boost::ordered_euclidean_ring_operators2<Wrapped6<T, U>, U>
|
||||
, boost::ordered_euclidean_ring_operators1<Wrapped6<T, U> >
|
||||
: boost::ordered_euclidian_ring_operators2<Wrapped6<T, U>, U>
|
||||
, boost::ordered_euclidian_ring_operators1<Wrapped6<T, U> >
|
||||
{
|
||||
public:
|
||||
explicit Wrapped6( T v = T() ) : _value(v) {}
|
||||
|
||||
94
swap.html
94
swap.html
@@ -1,94 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
<title>Boost: Swap Documentation</title>
|
||||
</head>
|
||||
<body>
|
||||
<!-- Page header -->
|
||||
<img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
|
||||
<h1>Swap</h1>
|
||||
|
||||
<p>
|
||||
<tt>template<class T> void swap(T& <em>left</em>, T& <em>right</em>);</tt>
|
||||
</p>
|
||||
|
||||
<!-- Introduction -->
|
||||
<p>
|
||||
The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
|
||||
</p>
|
||||
|
||||
<!-- Rationale -->
|
||||
<h2>Rationale</h2>
|
||||
<p>
|
||||
The generic <tt>std::swap</tt> function requires that the elements to be swapped are assignable and copy constructible. It is usually implemented using one copy construction and two assignments - this is often both unnecessarily restrictive and unnecessarily slow. In addition, where the generic swap implementation provides only the basic guarantee, specialized swap functions are often able to provide the no-throw exception guarantee (and it is considered best practice to do so where possible<sup><a href="#ref1">1</a></sup>).</p>
|
||||
<p>
|
||||
The alternative to using argument dependent lookup in this situation is to provide a template specialization of <tt>std::swap</tt> for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
|
||||
</p>
|
||||
<p>
|
||||
<tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> originally did not do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been accepted by the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.
|
||||
</p>
|
||||
|
||||
<!-- Exception Safety -->
|
||||
<h2>Exception Safety</h2>
|
||||
<p>
|
||||
<tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
|
||||
</p>
|
||||
|
||||
<!-- Requirements -->
|
||||
<h2>Requirements</h2>
|
||||
<p>Either:</p>
|
||||
<ul>
|
||||
<li>T must be assignable</li>
|
||||
<li>T must be copy constructible</li>
|
||||
</ul>
|
||||
<p>Or:</p>
|
||||
<ul>
|
||||
<li>A function with the signature <tt>swap(T&,T&)</tt> is available via argument dependent lookup</li>
|
||||
</ul>
|
||||
<p>Or:</p>
|
||||
<ul>
|
||||
<li>A template specialization of <tt>std::swap</tt> exists for T</li>
|
||||
</ul>
|
||||
<p>Or:</p>
|
||||
<ul>
|
||||
<li>T is a built-in array of swappable elements</li>
|
||||
</ul>
|
||||
|
||||
|
||||
<!-- Portability -->
|
||||
<h2>Portability</h2>
|
||||
<p>
|
||||
Several older compilers do not support argument dependent lookup ‒ on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
|
||||
</p>
|
||||
|
||||
<!-- Credits -->
|
||||
<h2>Credits</h2>
|
||||
<ul>
|
||||
<li>
|
||||
<em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
|
||||
</li>
|
||||
<li>
|
||||
<em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
|
||||
</li>
|
||||
<li>
|
||||
<em>Steven Watanabe</em> - for the idea to make <tt>boost::swap</tt> less specialized than <tt>std::swap</tt>, thereby allowing the function to have the name 'swap' without introducing ambiguity
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<!-- References -->
|
||||
<hr/>
|
||||
<p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
|
||||
<p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">LWG Defect Report 809 (std::swap should be overloaded for array types)</a></p>
|
||||
|
||||
<!-- Copyright info -->
|
||||
<hr/>
|
||||
<p>Revised: 15 November 2008</p>
|
||||
<p>
|
||||
Copyright 2007, 2008 Joseph Gauterin. Use, modification, and distribution are subject to the Boost Software License, Version 1.0.
|
||||
(See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at <<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>>.)
|
||||
</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,41 +0,0 @@
|
||||
#
|
||||
# Copyright Troy D. Straszheim
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See http://www.boost.org/LICENSE_1_0.txt
|
||||
#
|
||||
|
||||
foreach(T
|
||||
root_header_1 root_header_2
|
||||
lib_header_1 lib_header_2
|
||||
mixed_headers_1 mixed_headers_2)
|
||||
boost_test_compile(${T})
|
||||
endforeach()
|
||||
|
||||
|
||||
# [ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
|
||||
|
||||
foreach(T
|
||||
primitive
|
||||
specialized_in_boost
|
||||
specialized_in_global
|
||||
specialized_in_other
|
||||
specialized_in_std
|
||||
specialized_in_boost_and_other
|
||||
std_bitset
|
||||
std_dateorder
|
||||
std_string
|
||||
std_typeinfo_ptr
|
||||
std_vector_of_boost
|
||||
std_vector_of_global
|
||||
std_vector_of_other
|
||||
no_ambiguity_in_boost
|
||||
array_of_array_of_class
|
||||
array_of_array_of_int
|
||||
array_of_class
|
||||
array_of_int
|
||||
array_of_template)
|
||||
boost_test_run(${T} DEPENDS boost_test_exec_monitor)
|
||||
endforeach()
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
# Copyright (c) 2007, 2008 Joseph Gauterin
|
||||
#
|
||||
# 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)
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
test-suite utility/swap
|
||||
:
|
||||
[ compile root_header_1.cpp ]
|
||||
[ compile root_header_2.cpp ]
|
||||
[ compile lib_header_1.cpp ]
|
||||
[ compile lib_header_2.cpp ]
|
||||
[ compile mixed_headers_1.cpp ]
|
||||
[ compile mixed_headers_2.cpp ]
|
||||
[ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run specialized_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run specialized_in_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run specialized_in_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run specialized_in_std.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run specialized_in_boost_and_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_bitset.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_dateorder.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_string.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_typeinfo_ptr.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_vector_of_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_vector_of_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run std_vector_of_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run no_ambiguity_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run array_of_array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run array_of_array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
[ run array_of_template.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
|
||||
;
|
||||
@@ -1,69 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
#include <algorithm> //for std::copy and std::equal
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
//Provide swap function in both the namespace of swap_test_class
|
||||
//(which is the global namespace), and the std namespace.
|
||||
//It's common to provide a swap function for a class in both
|
||||
//namespaces. Scott Meyers recommends doing so: Effective C++,
|
||||
//Third Edition, item 25, "Consider support for a non-throwing swap".
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <>
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::size_t first_dimension = 3;
|
||||
const std::size_t second_dimension = 4;
|
||||
const std::size_t number_of_elements = first_dimension * second_dimension;
|
||||
|
||||
swap_test_class array1[first_dimension][second_dimension];
|
||||
swap_test_class array2[first_dimension][second_dimension];
|
||||
|
||||
swap_test_class* const ptr1 = array1[0];
|
||||
swap_test_class* const ptr2 = array2[0];
|
||||
|
||||
for (std::size_t i = 0; i < number_of_elements; ++i)
|
||||
{
|
||||
ptr1[i].set_data( static_cast<int>(i) );
|
||||
ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
|
||||
}
|
||||
|
||||
boost::swap(array1, array2);
|
||||
|
||||
for (std::size_t i = 0; i < number_of_elements; ++i)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(ptr1[i].get_data(), static_cast<int>(i + number_of_elements) );
|
||||
BOOST_CHECK_EQUAL(ptr2[i].get_data(), static_cast<int>(i) );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping an array of arrays of integers by means of boost::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <algorithm> //for std::copy and std::equal
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::size_t first_dimension = 3;
|
||||
const std::size_t second_dimension = 4;
|
||||
const std::size_t number_of_elements = first_dimension * second_dimension;
|
||||
|
||||
int array1[first_dimension][second_dimension];
|
||||
int array2[first_dimension][second_dimension];
|
||||
|
||||
int* const ptr1 = array1[0];
|
||||
int* const ptr2 = array2[0];
|
||||
|
||||
for (std::size_t i = 0; i < number_of_elements; ++i)
|
||||
{
|
||||
ptr1[i] = static_cast<int>(i);
|
||||
ptr2[i] = static_cast<int>(i + number_of_elements);
|
||||
}
|
||||
|
||||
boost::swap(array1, array2);
|
||||
|
||||
for (std::size_t i = 0; i < number_of_elements; ++i)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(ptr1[i], static_cast<int>(i + number_of_elements) );
|
||||
BOOST_CHECK_EQUAL(ptr2[i], static_cast<int>(i) );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
#include <algorithm> //for std::copy and std::equal
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
//Provide swap function in both the namespace of swap_test_class
|
||||
//(which is the global namespace), and the std namespace.
|
||||
//It's common to provide a swap function for a class in both
|
||||
//namespaces. Scott Meyers recommends doing so: Effective C++,
|
||||
//Third Edition, item 25, "Consider support for a non-throwing swap".
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <>
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::size_t array_size = 2;
|
||||
const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
|
||||
const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
|
||||
|
||||
swap_test_class array1[array_size];
|
||||
swap_test_class array2[array_size];
|
||||
|
||||
std::copy(initial_array1, initial_array1 + array_size, array1);
|
||||
std::copy(initial_array2, initial_array2 + array_size, array2);
|
||||
|
||||
swap_test_class::reset();
|
||||
boost::swap(array1, array2);
|
||||
|
||||
BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
|
||||
BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping an array of integers by means of boost::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <algorithm> //for std::copy and std::equal
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::size_t array_size = 3;
|
||||
const int initial_array1[array_size] = { 1, 2, 3 };
|
||||
const int initial_array2[array_size] = { 4, 5, 6 };
|
||||
|
||||
int array1[array_size];
|
||||
int array2[array_size];
|
||||
|
||||
std::copy(initial_array1, initial_array1 + array_size, array1);
|
||||
std::copy(initial_array2, initial_array2 + array_size, array2);
|
||||
|
||||
boost::swap(array1, array2);
|
||||
|
||||
BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
|
||||
BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping an array of swap_test_template<int> objects by means of boost::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
#include <algorithm> //for std::copy and std::equal
|
||||
#include <cstddef> //for std::size_t
|
||||
|
||||
template <class T>
|
||||
class swap_test_template
|
||||
{
|
||||
public:
|
||||
typedef T template_argument;
|
||||
swap_test_class swap_test_object;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
inline bool operator==(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
|
||||
{
|
||||
return lhs.swap_test_object == rhs.swap_test_object;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline bool operator!=(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
//Provide swap function in the namespace of swap_test_template
|
||||
//(which is the global namespace). Note that it isn't allowed to put
|
||||
//an overload of this function within the std namespace.
|
||||
template <class T>
|
||||
void swap(swap_test_template<T>& left, swap_test_template<T>& right)
|
||||
{
|
||||
left.swap_test_object.swap(right.swap_test_object);
|
||||
}
|
||||
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::size_t array_size = 2;
|
||||
const swap_test_template<int> initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
|
||||
const swap_test_template<int> initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
|
||||
|
||||
swap_test_template<int> array1[array_size];
|
||||
swap_test_template<int> array2[array_size];
|
||||
|
||||
std::copy(initial_array1, initial_array1 + array_size, array1);
|
||||
std::copy(initial_array2, initial_array2 + array_size, array2);
|
||||
|
||||
swap_test_class::reset();
|
||||
boost::swap(array1, array2);
|
||||
|
||||
BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
|
||||
BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap header compiles as a standalone translation unit
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap header include guards work correctly
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#include <boost/utility/swap.hpp>
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap headers work when both are included
|
||||
|
||||
#include <boost/swap.hpp>
|
||||
#include <boost/utility/swap.hpp>
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap headers work when both are included
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#include <boost/swap.hpp>
|
||||
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// boost::swap internally does an unqualified function call to swap.
|
||||
// This could have led to ambiguity or infinite recursion, when the
|
||||
// objects to be swapped would themselves be from the boost namespace.
|
||||
// If so, boost::swap itself might be found by argument dependent lookup.
|
||||
// The implementation of boost::swap resolves this issue by giving
|
||||
// boost::swap two template argumetns, thereby making it less specialized
|
||||
// than std::swap.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const boost::swap_test_class initial_value1(1);
|
||||
const boost::swap_test_class initial_value2(2);
|
||||
|
||||
boost::swap_test_class object1 = initial_value1;
|
||||
boost::swap_test_class object2 = initial_value2;
|
||||
|
||||
boost::swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
|
||||
BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
int object1 = 1;
|
||||
int object2 = 2;
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1,2);
|
||||
BOOST_CHECK_EQUAL(object2,1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap header compiles as a standalone translation unit
|
||||
|
||||
#include <boost/swap.hpp>
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests that the swap header include guards work correctly
|
||||
|
||||
#include <boost/swap.hpp>
|
||||
#include <boost/swap.hpp>
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
//Provide swap function in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const boost::swap_test_class initial_value1(1);
|
||||
const boost::swap_test_class initial_value2(2);
|
||||
|
||||
boost::swap_test_class object1 = initial_value1;
|
||||
boost::swap_test_class object2 = initial_value2;
|
||||
|
||||
boost::swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
|
||||
BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,64 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests whether instances of a class from a namespace other than boost are
|
||||
// properly swapped, when both boost and the other namespace have a custom
|
||||
// swap function for that class. Note that it shouldn't be necessary for a class
|
||||
// in an other namespace to have a custom swap function in boost, because the
|
||||
// boost::swap utility should find the swap function in the other namespace, by
|
||||
// argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
|
||||
// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and
|
||||
// Borland 5.9.3. Users of those compilers might consider adding a swap overload
|
||||
// to the boost namespace.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in namespace other
|
||||
namespace other
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
//Provide swap function in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
void swap(::other::swap_test_class& left, ::other::swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
//Provide swap function in namespace other
|
||||
namespace other
|
||||
{
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const other::swap_test_class initial_value1(1);
|
||||
const other::swap_test_class initial_value2(2);
|
||||
|
||||
other::swap_test_class object1 = initial_value1;
|
||||
other::swap_test_class object2 = initial_value2;
|
||||
|
||||
other::swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
|
||||
BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,39 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
//Provide swap function in gloabl namespace
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const swap_test_class initial_value1(1);
|
||||
const swap_test_class initial_value2(2);
|
||||
|
||||
swap_test_class object1 = initial_value1;
|
||||
swap_test_class object2 = initial_value2;
|
||||
|
||||
swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in namespace other
|
||||
namespace other
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
//Provide swap function in namespace other
|
||||
namespace other
|
||||
{
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const other::swap_test_class initial_value1(1);
|
||||
const other::swap_test_class initial_value2(2);
|
||||
|
||||
other::swap_test_class object1 = initial_value1;
|
||||
other::swap_test_class object2 = initial_value2;
|
||||
|
||||
other::swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
|
||||
BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
// Copyright (c) 2007 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
|
||||
//Provide swap function in namespace std
|
||||
namespace std
|
||||
{
|
||||
template <>
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const swap_test_class initial_value1(1);
|
||||
const swap_test_class initial_value2(2);
|
||||
|
||||
swap_test_class object1 = initial_value1;
|
||||
swap_test_class object2 = initial_value2;
|
||||
|
||||
swap_test_class::reset();
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::bitset<T> objects by means of boost::swap.
|
||||
// Unlike most other Standard C++ Library template classes,
|
||||
// std::bitset<T> does not have its own std::swap overload.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <bitset>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
typedef std::bitset<8> bitset_type;
|
||||
const bitset_type initial_value1 = 1ul;
|
||||
const bitset_type initial_value2 = 2ul;
|
||||
|
||||
bitset_type object1 = initial_value1;
|
||||
bitset_type object2 = initial_value2;
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1,initial_value2);
|
||||
BOOST_CHECK_EQUAL(object2,initial_value1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::time_base::dateorder objects by means of boost::swap.
|
||||
// std::time_base::dateorder is an enumerated type. It does not have an
|
||||
// std::swap overload or template specialization.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <locale>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::time_base::dateorder initial_value1 = std::time_base::dmy;
|
||||
const std::time_base::dateorder initial_value2 = std::time_base::mdy;
|
||||
|
||||
std::time_base::dateorder object1 = initial_value1;
|
||||
std::time_base::dateorder object2 = initial_value2;
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1,initial_value2);
|
||||
BOOST_CHECK_EQUAL(object2,initial_value1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::string objects by means of boost::swap.
|
||||
// std::string has its own std::swap overload.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <string>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::string initial_value1 = "one";
|
||||
const std::string initial_value2 = "two";
|
||||
|
||||
std::string object1 = initial_value1;
|
||||
std::string object2 = initial_value2;
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1,initial_value2);
|
||||
BOOST_CHECK_EQUAL(object2,initial_value1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::type_info pointers by means of boost::swap.
|
||||
// There is no std::swap overload or template specialization
|
||||
// for std::type_info pointers.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <typeinfo>
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
const std::type_info * const initial_value1 = 0;
|
||||
const std::type_info * const initial_value2 = &typeid(double);
|
||||
|
||||
const std::type_info * ptr1 = initial_value1;
|
||||
const std::type_info * ptr2 = initial_value2;
|
||||
|
||||
boost::swap(ptr1,ptr2);
|
||||
|
||||
BOOST_CHECK_EQUAL(ptr1,initial_value2);
|
||||
BOOST_CHECK_EQUAL(ptr2,initial_value1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::vector objects by means of boost::swap,
|
||||
// having boost::swap_test_class as vector element type.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <vector>
|
||||
|
||||
//Put test class in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
//Provide swap function in namespace boost
|
||||
namespace boost
|
||||
{
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
typedef boost::swap_test_class swap_test_class_type;
|
||||
typedef std::vector<swap_test_class_type> vector_type;
|
||||
|
||||
const vector_type::size_type initial_size1 = 1;
|
||||
const vector_type::size_type initial_size2 = 2;
|
||||
|
||||
const vector_type initial_value1(initial_size1, swap_test_class_type(1));
|
||||
const vector_type initial_value2(initial_size2, swap_test_class_type(2));
|
||||
|
||||
vector_type object1 = initial_value1;
|
||||
vector_type object2 = initial_value2;
|
||||
|
||||
swap_test_class_type::reset();
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1.size(),initial_size2);
|
||||
BOOST_CHECK_EQUAL(object2.size(),initial_size1);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
|
||||
BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::vector objects by means of boost::swap,
|
||||
// having ::swap_test_class as vector element type.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <vector>
|
||||
|
||||
//Put test class in the global namespace
|
||||
#include "./swap_test_class.hpp"
|
||||
|
||||
//Provide swap function in the global namespace
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
typedef std::vector<swap_test_class> vector_type;
|
||||
|
||||
const vector_type::size_type initial_size1 = 1;
|
||||
const vector_type::size_type initial_size2 = 2;
|
||||
|
||||
const vector_type initial_value1(initial_size1, swap_test_class(1));
|
||||
const vector_type initial_value2(initial_size2, swap_test_class(2));
|
||||
|
||||
vector_type object1 = initial_value1;
|
||||
vector_type object2 = initial_value2;
|
||||
|
||||
swap_test_class::reset();
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1.size(),initial_size2);
|
||||
BOOST_CHECK_EQUAL(object2.size(),initial_size1);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class::swap_count(),0);
|
||||
BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests swapping std::vector objects by means of boost::swap,
|
||||
// having other::swap_test_class as vector element type.
|
||||
|
||||
#include <boost/utility/swap.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
#include <vector>
|
||||
|
||||
//Put test class in namespace other
|
||||
namespace other
|
||||
{
|
||||
#include "./swap_test_class.hpp"
|
||||
}
|
||||
|
||||
//Provide swap function in namespace other
|
||||
namespace other
|
||||
{
|
||||
void swap(swap_test_class& left, swap_test_class& right)
|
||||
{
|
||||
left.swap(right);
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
typedef other::swap_test_class swap_test_class_type;
|
||||
typedef std::vector<swap_test_class_type> vector_type;
|
||||
|
||||
const vector_type::size_type initial_size1 = 1;
|
||||
const vector_type::size_type initial_size2 = 2;
|
||||
|
||||
const vector_type initial_value1(initial_size1, swap_test_class_type(1));
|
||||
const vector_type initial_value2(initial_size2, swap_test_class_type(2));
|
||||
|
||||
vector_type object1 = initial_value1;
|
||||
vector_type object2 = initial_value2;
|
||||
|
||||
swap_test_class_type::reset();
|
||||
|
||||
boost::swap(object1,object2);
|
||||
|
||||
BOOST_CHECK_EQUAL(object1.size(),initial_size2);
|
||||
BOOST_CHECK_EQUAL(object2.size(),initial_size1);
|
||||
|
||||
BOOST_CHECK(object1 == initial_value2);
|
||||
BOOST_CHECK(object2 == initial_value1);
|
||||
|
||||
BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
|
||||
BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,114 +0,0 @@
|
||||
// Copyright (c) 2007-2008 Joseph Gauterin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// Tests class used by the Boost.Swap tests
|
||||
|
||||
#ifndef BOOST_UTILITY_SWAP_TEST_CLASS_HPP
|
||||
#define BOOST_UTILITY_SWAP_TEST_CLASS_HPP
|
||||
|
||||
|
||||
class swap_test_class
|
||||
{
|
||||
int m_data;
|
||||
public:
|
||||
explicit swap_test_class(int arg = 0)
|
||||
:
|
||||
m_data(arg)
|
||||
{
|
||||
++constructCount();
|
||||
}
|
||||
|
||||
~swap_test_class()
|
||||
{
|
||||
++destructCount();
|
||||
}
|
||||
|
||||
swap_test_class(const swap_test_class& arg)
|
||||
:
|
||||
m_data(arg.m_data)
|
||||
{
|
||||
++copyCount();
|
||||
++destructCount();
|
||||
}
|
||||
|
||||
swap_test_class& operator=(const swap_test_class& arg)
|
||||
{
|
||||
m_data = arg.m_data;
|
||||
++copyCount();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void swap(swap_test_class& other)
|
||||
{
|
||||
const int temp = m_data;
|
||||
m_data = other.m_data;
|
||||
other.m_data = temp;
|
||||
|
||||
++swapCount();
|
||||
}
|
||||
|
||||
int get_data() const
|
||||
{
|
||||
return m_data;
|
||||
}
|
||||
|
||||
void set_data(int arg)
|
||||
{
|
||||
m_data = arg;
|
||||
}
|
||||
|
||||
static unsigned int swap_count(){ return swapCount(); }
|
||||
static unsigned int copy_count(){ return copyCount(); }
|
||||
static unsigned int construct_count(){ return constructCount(); }
|
||||
static unsigned int destruct_count(){ return destructCount(); }
|
||||
|
||||
static void reset()
|
||||
{
|
||||
swapCount() = 0;
|
||||
copyCount() = 0;
|
||||
constructCount() = 0;
|
||||
destructCount() = 0;
|
||||
}
|
||||
|
||||
private:
|
||||
static unsigned int& swapCount()
|
||||
{
|
||||
static unsigned int value = 0;
|
||||
return value;
|
||||
}
|
||||
|
||||
static unsigned int& copyCount()
|
||||
{
|
||||
static unsigned int value = 0;
|
||||
return value;
|
||||
}
|
||||
|
||||
static unsigned int& constructCount()
|
||||
{
|
||||
static unsigned int value = 0;
|
||||
return value;
|
||||
}
|
||||
|
||||
static unsigned int& destructCount()
|
||||
{
|
||||
static unsigned int value = 0;
|
||||
return value;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
inline bool operator==(const swap_test_class & lhs, const swap_test_class & rhs)
|
||||
{
|
||||
return lhs.get_data() == rhs.get_data();
|
||||
}
|
||||
|
||||
inline bool operator!=(const swap_test_class & lhs, const swap_test_class & rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,47 +0,0 @@
|
||||
#
|
||||
# Copyright Troy D. Straszheim
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See http://www.boost.org/LICENSE_1_0.txt
|
||||
#
|
||||
boost_additional_test_dependencies(utility BOOST_DEPENDS test)
|
||||
|
||||
boost_test_run(addressof_fn_test ../addressof_fn_test.cpp)
|
||||
boost_test_run(addressof_test ../addressof_test.cpp)
|
||||
boost_test_run(addressof_test2 ../addressof_test2.cpp)
|
||||
boost_test_run(assert_test ../assert_test.cpp)
|
||||
boost_test_run(base_from_member_test ../base_from_member_test.cpp)
|
||||
boost_test_run(binary_search_test ../binary_search_test.cpp)
|
||||
boost_test_run(call_traits_test ../call_traits_test.cpp ARGS -u)
|
||||
boost_test_compile_fail(checked_delete_test ../checked_delete_test.cpp)
|
||||
boost_test_run(compressed_pair_test
|
||||
../compressed_pair_test
|
||||
DEPENDS boost_test_exec_monitor)
|
||||
boost_test_run(current_function_test ../current_function_test.cpp)
|
||||
boost_test_run(iterators_test
|
||||
../iterators_test.cpp
|
||||
DEPENDS boost_test_exec_monitor)
|
||||
boost_test_run(next_prior_test DEPENDS boost_test_exec_monitor)
|
||||
boost_test_compile_fail(noncopyable_test ../noncopyable_test.cpp)
|
||||
boost_test_run(numeric_traits_test ../numeric_traits_test.cpp)
|
||||
if (${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
|
||||
boost_test_compile_fail("operators_test_compilerbug")
|
||||
elseif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
|
||||
boost_test_run(operators_test
|
||||
../operators_test.cpp
|
||||
DEPENDS boost_test_exec_monitor)
|
||||
endif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
|
||||
boost_test_compile(ref_ct_test ../ref_ct_test.cpp)
|
||||
boost_test_run(ref_test
|
||||
../ref_test.cpp
|
||||
DEPENDS boost_test_exec_monitor)
|
||||
boost_test_compile(result_of_test)
|
||||
boost_test_run(shared_iterator_test ../shared_iterator_test.cpp)
|
||||
boost_test_run(value_init_test ../value_init_test.cpp)
|
||||
boost_test_compile_fail(value_init_test_fail1
|
||||
../value_init_test_fail1.cpp)
|
||||
boost_test_compile_fail(value_init_test_fail2
|
||||
../value_init_test_fail2.cpp)
|
||||
boost_test_compile_fail(value_init_test_fail3
|
||||
../value_init_test_fail3.cpp)
|
||||
boost_test_run(verify_test ../verify_test.cpp)
|
||||
@@ -11,13 +11,10 @@ import testing ;
|
||||
# Please keep the tests ordered by filename
|
||||
test-suite utility
|
||||
:
|
||||
[ run ../addressof_fn_test.cpp ]
|
||||
[ run ../addressof_test.cpp ]
|
||||
[ run ../addressof_test2.cpp ]
|
||||
[ run ../assert_test.cpp ]
|
||||
[ run ../base_from_member_test.cpp ]
|
||||
[ run ../binary_search_test.cpp ]
|
||||
[ run ../binary_test.cpp ]
|
||||
[ run ../call_traits_test.cpp : -u ]
|
||||
[ compile-fail ../checked_delete_test.cpp ]
|
||||
[ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor/<link>static : -u ]
|
||||
|
||||
@@ -11,35 +11,101 @@
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
struct int_result_type { typedef int result_type; };
|
||||
struct int_result_type
|
||||
{
|
||||
typedef int result_type;
|
||||
result_type operator()(float);
|
||||
};
|
||||
|
||||
struct int_result_of
|
||||
{
|
||||
template<typename F> struct result { typedef int type; };
|
||||
result<int_result_of(double)>::type operator()(double);
|
||||
result<const int_result_of(double)>::type operator()(double) const;
|
||||
result<int_result_of()>::type operator()();
|
||||
result<volatile int_result_of()>::type operator()() volatile;
|
||||
};
|
||||
|
||||
struct int_result_type_and_float_result_of
|
||||
struct int_result_type_and_float_result_of_and_char_return
|
||||
{
|
||||
typedef int result_type;
|
||||
template<typename F> struct result { typedef float type; };
|
||||
char operator()(char);
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct int_result_type_template { typedef int result_type; };
|
||||
struct int_result_type_template
|
||||
{
|
||||
typedef int result_type;
|
||||
result_type operator()(float);
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct int_result_of_template
|
||||
{
|
||||
template<typename F> struct result;
|
||||
template<typename This, typename That> struct result<This(That)> { typedef int type; };
|
||||
typename result<int_result_of_template<T>(double)>::type operator()(double);
|
||||
typename result<const int_result_of_template<T>(double)>::type operator()(double) const;
|
||||
typename result<int_result_of_template<T>(double)>::type operator()();
|
||||
typename result<volatile int_result_of_template<T>(double)>::type operator()() volatile;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct int_result_type_and_float_result_of_template
|
||||
struct int_result_type_and_float_result_of_and_char_return_template
|
||||
{
|
||||
typedef int result_type;
|
||||
template<typename F> struct result;
|
||||
template<typename This, typename That> struct result<This(That)> { typedef float type; };
|
||||
char operator()(char);
|
||||
};
|
||||
|
||||
struct result_of_member_function_template
|
||||
{
|
||||
template<typename F> struct result;
|
||||
|
||||
template<typename This, typename That> struct result<This(That)> { typedef That type; };
|
||||
template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);
|
||||
|
||||
template<typename This, typename That> struct result<const This(That)> { typedef const That type; };
|
||||
template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;
|
||||
|
||||
template<typename This, typename That> struct result<volatile This(That)> { typedef volatile That type; };
|
||||
template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;
|
||||
|
||||
template<typename This, typename That> struct result<const volatile This(That)> { typedef const volatile That type; };
|
||||
template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;
|
||||
|
||||
template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
|
||||
template<class T> typename result<result_of_member_function_template(T &, T)>::type operator()(T &, T);
|
||||
|
||||
template<typename This, typename That> struct result<This(That const &, That)> { typedef That const & type; };
|
||||
template<class T> typename result<result_of_member_function_template(T const &, T)>::type operator()(T const &, T);
|
||||
|
||||
template<typename This, typename That> struct result<This(That volatile &, That)> { typedef That volatile & type; };
|
||||
template<class T> typename result<result_of_member_function_template(T volatile &, T)>::type operator()(T volatile &, T);
|
||||
|
||||
template<typename This, typename That> struct result<This(That const volatile &, That)> { typedef That const volatile & type; };
|
||||
template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
|
||||
};
|
||||
|
||||
struct no_result_type_or_result_of
|
||||
{
|
||||
int operator()(double);
|
||||
short operator()(double) const;
|
||||
unsigned int operator()();
|
||||
unsigned short operator()() volatile;
|
||||
const unsigned short operator()() const volatile;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct no_result_type_or_result_of_template
|
||||
{
|
||||
int operator()(double);
|
||||
short operator()(double) const;
|
||||
unsigned int operator()();
|
||||
unsigned short operator()() volatile;
|
||||
const unsigned short operator()() const volatile;
|
||||
};
|
||||
|
||||
struct X {};
|
||||
@@ -60,16 +126,37 @@ int main()
|
||||
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_template<void>(float)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(double)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of_template<void>(double)>::type, int>::value));
|
||||
|
||||
// Prior to decltype, result_of could not deduce the return type
|
||||
// nullary function objects unless they exposed a result_type.
|
||||
#if defined(BOOST_HAS_DECLTYPE)
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, int>::value));
|
||||
#else
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_template<void>(char)>::type, int>::value));
|
||||
#endif
|
||||
|
||||
// Prior to decltype, result_of ignored a nested result<> if
|
||||
// result_type was defined. After decltype, result_of deduces the
|
||||
// actual return type of the function object, ignoring both
|
||||
// result<> and result_type.
|
||||
#if defined(BOOST_HAS_DECLTYPE)
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
|
||||
#else
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
|
||||
#endif
|
||||
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value));
|
||||
@@ -81,5 +168,27 @@ int main()
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(void)>::type, int>::value));
|
||||
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, const double>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
|
||||
|
||||
#if defined(BOOST_HAS_DECLTYPE)
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(double)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(void)>::type, unsigned int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of(double)>::type, short>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of(void)>::type, unsigned short>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of(void)>::type, const unsigned short>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(double)>::type, int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(void)>::type, unsigned int>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of_template<void>(double)>::type, short>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of_template<void>(void)>::type, unsigned short>::value));
|
||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of_template<void>(void)>::type, const unsigned short>::value));
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,15 +1,58 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv=refresh content="0; URL=../exception/doc/throw_exception.html">
|
||||
<title>Automatic redirection</title>
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../exception/doc/throw_exception.html">throw_exception.html</a>. <hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
</body>
|
||||
<head>
|
||||
<title>Boost: throw_exception.hpp documentation</title>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
</head>
|
||||
<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
|
||||
<table border="0" width="100%">
|
||||
<tr>
|
||||
<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
|
||||
</td>
|
||||
<td align="center">
|
||||
<h1>throw_exception.hpp</h1>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="2" height="64"> </td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>
|
||||
The header <STRONG><boost/throw_exception.hpp></STRONG> defines the
|
||||
helper function <STRONG>boost::throw_exception</STRONG>. It is intended to be
|
||||
used in Boost libraries that need to throw exceptions, but support
|
||||
configurations and platforms where exceptions aren't available, as indicated by
|
||||
the presence of the <STRONG>BOOST_NO_EXCEPTIONS</STRONG> <A href="../config/config.htm#macro_ref">
|
||||
configuration macro</A>.
|
||||
</p>
|
||||
<P>When <STRONG>BOOST_NO_EXCEPTIONS</STRONG> is not defined, <tt>boost::throw_exception(e)</tt>
|
||||
is equivalent to <tt>throw e</tt>. Otherwise, the function is left undefined,
|
||||
and the user is expected to supply an appropriate definition. Callers of <tt>throw_exception</tt>
|
||||
are allowed to assume that the function never returns; therefore, if the
|
||||
user-defined <tt>throw_exception</tt> returns, the behavior is undefined.</P>
|
||||
<h3><a name="Synopsis">Synopsis</a></h3>
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
|
||||
#ifdef BOOST_NO_EXCEPTIONS
|
||||
|
||||
void throw_exception(std::exception const & e); // user defined
|
||||
|
||||
#else
|
||||
|
||||
template<class E> void throw_exception(E const & e)
|
||||
{
|
||||
throw e;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
</pre>
|
||||
<p><br>
|
||||
<small>Copyright <20> 2002 by Peter Dimov. Distributed under the Boost Software License, Version
|
||||
1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or
|
||||
copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
68
utility.htm
68
utility.htm
@@ -23,8 +23,6 @@
|
||||
<li>
|
||||
Function template <a href="#addressof">addressof()</a></li>
|
||||
<li>Class template <a href="#result_of">result_of</a></li>
|
||||
<li>
|
||||
Macro <a href="#BOOST_BINARY">BOOST_BINARY</a></li>
|
||||
<li><a href="index.html">Other utilities not part of <code>utility.hpp</code></a></li>
|
||||
</ul>
|
||||
<h2>
|
||||
@@ -154,11 +152,13 @@ void f() {
|
||||
...,t<em>N</em>)</code>. The implementation permits
|
||||
the type <code>F</code> to be a function pointer,
|
||||
function reference, member function pointer, or class
|
||||
type. When <code>F</code> is a class type with a
|
||||
member type <code>result_type</code>,
|
||||
type.</p> <p>If your compiler does not support
|
||||
<code>decltype</code>, then when <code>F</code> is a
|
||||
class type with a member type <code>result_type</code>,
|
||||
<code>result_of<F(T1, T2, ...,
|
||||
T<em>N</em>)></code> is
|
||||
<code>F::result_type</code>. Otherwise,
|
||||
<code>F::result_type</code>. When <code>F</code>
|
||||
does not contain <code>result_type</code>,
|
||||
<code>result_of<F(T1, T2, ...,
|
||||
T<em>N</em>)></code> is <code>F::result<F(T1,
|
||||
T2, ..., T<em>N</em>)>::type</code> when
|
||||
@@ -183,63 +183,9 @@ void f() {
|
||||
|
||||
<h2>Class templates for the Base-from-Member Idiom</h2>
|
||||
<p>See <a href="base_from_member.html">separate documentation</a>.</p>
|
||||
<h2><a name="BOOST_BINARY">Macro BOOST_BINARY</a></h2>
|
||||
|
||||
<p>The macro <code>BOOST_BINARY</code> is used for the
|
||||
representation of binary literals. It takes as an argument
|
||||
a binary number arranged as an arbitrary amount of 1s and 0s in
|
||||
groupings of length 1 to 8, with groups separated
|
||||
by spaces. The type of the literal yielded is determined by
|
||||
the same rules as those of hex and octal
|
||||
literals (<i>2.13.1p1</i>). By implementation, this macro
|
||||
expands directly to an octal literal during preprocessing, so
|
||||
there is no overhead at runtime and the result is useable in
|
||||
any place that an octal literal would be.</p>
|
||||
|
||||
<p>In order to directly support binary literals with suffixes,
|
||||
additional macros of the form BOOST_BINARY_XXX are also
|
||||
provided, where XXX is a standard integer suffix in all capital
|
||||
letters. In addition, LL and ULL suffixes may be used for representing
|
||||
long long and unsigned long long types in compilers which provide
|
||||
them as an extension.</p>
|
||||
|
||||
|
||||
<p>The BOOST_BINARY family of macros resides in the header
|
||||
<a
|
||||
href="../../boost/utility/binary.hpp"><boost/utility/binary.hpp></a>
|
||||
which is automatically included by
|
||||
<a
|
||||
href="../../boost/utility.hpp"><boost/utility.hpp></a>.
|
||||
|
||||
<p>Contributed by Matt Calabrese.</p><p>
|
||||
</p><h3>Example</h3>
|
||||
<blockquote>
|
||||
<pre>
|
||||
void foo( int );
|
||||
|
||||
void foo( unsigned long );
|
||||
|
||||
void bar()
|
||||
{
|
||||
int value1 = BOOST_BINARY( 100 111000 01 1 110 );
|
||||
|
||||
unsigned long value2 = BOOST_BINARY_UL( 100 001 ); // unsigned long
|
||||
|
||||
long long value3 = BOOST_BINARY_LL( 11 000 ); // long long if supported
|
||||
|
||||
assert( BOOST_BINARY( 10010 )
|
||||
& BOOST_BINARY( 11000 )
|
||||
== BOOST_BINARY( 10000 )
|
||||
);
|
||||
|
||||
foo( BOOST_BINARY( 1010 ) ); // calls the first foo
|
||||
|
||||
foo( BOOST_BINARY_LU( 1010 ) ); // calls the second foo
|
||||
}
|
||||
</pre></blockquote>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
|
||||
-->04 September, 2008<!--webbot bot="Timestamp" endspan i-checksum="39369"
|
||||
-->07 November, 2007<!--webbot bot="Timestamp" endspan i-checksum="39369"
|
||||
-->
|
||||
</p>
|
||||
<p>© Copyright Beman Dawes 1999-2003.</p>
|
||||
@@ -247,4 +193,4 @@ void bar()
|
||||
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
@@ -253,7 +253,7 @@ its internal data, prior to constructing the object that it contains.
|
||||
|
||||
<h2><a name="val_init"><code>template class value_initialized<T></code></a></h2>
|
||||
|
||||
<pre>namespace boost {<br><br>template<class T><br>class value_initialized<br>{<br> public :<br> value_initialized() : x() {}<br> operator T&() const { return x ; }<br> T& data() const { return x ; }<br> void swap( value_initialized<T>& );<br><br> private :<br> <i>unspecified</i> x ;<br>} ;<br><br>template<class T><br>T const& get ( value_initialized<T> const& x )<br>{<br> return x.data() ;<br>}<br><br>template<class T><br>T& get ( value_initialized<T>& x )<br>{<br> return x.data() ;<br>}<br><br>} // namespace boost<br></pre>
|
||||
<pre>namespace boost {<br><br>template<class T><br>class value_initialized<br>{<br> public :<br> value_initialized() : x() {}<br> operator T&() const { return x ; }<br> T& data() const { return x ; }<br><br> private :<br> <i>unspecified</i> x ;<br>} ;<br><br>template<class T><br>T const& get ( value_initialized<T> const& x )<br>{<br> return x.data() ;<br>}<br><br>template<class T><br>T& get ( value_initialized<T>& x )<br>{<br> return x.data() ;<br>}<br><br>} // namespace boost<br></pre>
|
||||
|
||||
<p>An object of this template class is a <code>T</code>-wrapper convertible
|
||||
to <code>'T&'</code> whose wrapped object (data member of type <code>T</code>)
|
||||
@@ -276,10 +276,6 @@ non-member function <code>get()</code>: </p>
|
||||
<p>Both <code>const</code> and non-<code>const</code> objects can be wrapped.
|
||||
Mutable objects can be modified directly from within the wrapper but constant
|
||||
objects cannot:</p>
|
||||
|
||||
<p>When <code>T</code> is a <em>Swappable</em> type, <code>value_initialized<T></code>
|
||||
is swappable as well, by calling its <code>swap</code> member function
|
||||
as well as by calling <code>boost::swap</code>.</p>
|
||||
|
||||
<pre>value_initialized<int> x ; <br>static_cast<int&>(x) = 1 ; // OK<br>get(x) = 1 ; // OK<br><br>value_initialized<int const> y ; <br>static_cast<int&>(y) = 1 ; // ERROR: cannot cast to int&<br>static_cast<int const&>(y) = 1 ; // ERROR: cannot modify a const value<br>get(y) = 1 ; // ERROR: cannot modify a const value</pre>
|
||||
|
||||
@@ -383,7 +379,7 @@ for Boost release version 1.35 (2008), offering a workaround to various compiler
|
||||
</p>
|
||||
|
||||
<hr>
|
||||
<p>Revised 28 August 2008</p>
|
||||
<p>Revised 23 May 2008</p>
|
||||
|
||||
<p>© Copyright Fernando Cacciola, 2002, 2008.</p>
|
||||
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
// 21 Ago 2002 (Created) Fernando Cacciola
|
||||
// 15 Jan 2008 (Added tests regarding compiler issues) Fernando Cacciola, Niels Dekker
|
||||
// 23 May 2008 (Added tests regarding initialized_value) Niels Dekker
|
||||
// 21 Ago 2008 (Added swap test) Niels Dekker
|
||||
|
||||
#include <cstring> // For memcmp.
|
||||
#include <iostream>
|
||||
@@ -182,35 +181,6 @@ struct CopyFunctionCallTester
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// A struct that allows testing whether its customized swap function is called.
|
||||
//
|
||||
struct SwapFunctionCallTester
|
||||
{
|
||||
bool is_custom_swap_called;
|
||||
int data;
|
||||
|
||||
SwapFunctionCallTester()
|
||||
: is_custom_swap_called(false), data(0) {}
|
||||
|
||||
SwapFunctionCallTester(const SwapFunctionCallTester & arg)
|
||||
: is_custom_swap_called(false), data(arg.data) {}
|
||||
|
||||
void swap(SwapFunctionCallTester & arg)
|
||||
{
|
||||
std::swap(data, arg.data);
|
||||
is_custom_swap_called = true;
|
||||
arg.is_custom_swap_called = true;
|
||||
}
|
||||
};
|
||||
|
||||
void swap(SwapFunctionCallTester & lhs, SwapFunctionCallTester & rhs)
|
||||
{
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<class T>
|
||||
void check_initialized_value ( T const& y )
|
||||
{
|
||||
@@ -353,20 +323,9 @@ int test_main(int, char **)
|
||||
BOOST_CHECK ( ! get(copyFunctionCallTester3).is_copy_constructed);
|
||||
BOOST_CHECK ( get(copyFunctionCallTester3).is_assignment_called);
|
||||
|
||||
boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester1;
|
||||
boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester2;
|
||||
get(swapFunctionCallTester1).data = 1;
|
||||
get(swapFunctionCallTester2).data = 2;
|
||||
boost::swap(swapFunctionCallTester1, swapFunctionCallTester2);
|
||||
BOOST_CHECK( get(swapFunctionCallTester1).data == 2 );
|
||||
BOOST_CHECK( get(swapFunctionCallTester2).data == 1 );
|
||||
BOOST_CHECK( get(swapFunctionCallTester1).is_custom_swap_called );
|
||||
BOOST_CHECK( get(swapFunctionCallTester2).is_custom_swap_called );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
unsigned int expected_failures = 0;
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user