[boost-doc-zh] r381 committed - 升级至1.42.0,第七批,libs/目录t-z子目录

  • From: boost-doc-zh@xxxxxxxxxxxxxx
  • To: boost-doc-zh-notify@xxxxxxxxxxxxx
  • Date: Tue, 09 Feb 2010 07:00:30 +0000

Revision: 381
Author: alai04
Date: Mon Feb  8 22:59:49 2010
Log: 升级至1.42.0,第七批,libs/目录t-z子目录
http://code.google.com/p/boost-doc-zh/source/detail?r=381

Added:
 /trunk/libs/type_traits/doc/Jamfile.v2
 /trunk/libs/type_traits/doc/add_const.qbk
 /trunk/libs/type_traits/doc/add_cv.qbk
 /trunk/libs/type_traits/doc/add_pointer.qbk
 /trunk/libs/type_traits/doc/add_reference.qbk
 /trunk/libs/type_traits/doc/add_volatile.qbk
 /trunk/libs/type_traits/doc/aligned_storage.qbk
 /trunk/libs/type_traits/doc/alignment_of.qbk
 /trunk/libs/type_traits/doc/alignment_traits.qbk
 /trunk/libs/type_traits/doc/background.qbk
 /trunk/libs/type_traits/doc/credits.qbk
 /trunk/libs/type_traits/doc/decay.qbk
 /trunk/libs/type_traits/doc/decomposing_func.qbk
 /trunk/libs/type_traits/doc/examples.qbk
 /trunk/libs/type_traits/doc/extent.qbk
 /trunk/libs/type_traits/doc/floating_point_promotion.qbk
 /trunk/libs/type_traits/doc/function_traits.qbk
 /trunk/libs/type_traits/doc/has_new_operator.qbk
 /trunk/libs/type_traits/doc/has_nothrow_assign.qbk
 /trunk/libs/type_traits/doc/has_nothrow_constructor.qbk
 /trunk/libs/type_traits/doc/has_nothrow_copy.qbk
 /trunk/libs/type_traits/doc/has_trivial_assign.qbk
 /trunk/libs/type_traits/doc/has_trivial_constructor.qbk
 /trunk/libs/type_traits/doc/has_trivial_copy.qbk
 /trunk/libs/type_traits/doc/has_trivial_destructor.qbk
 /trunk/libs/type_traits/doc/has_virtual_destructor.qbk
 /trunk/libs/type_traits/doc/history.qbk
 /trunk/libs/type_traits/doc/integral_constant.qbk
 /trunk/libs/type_traits/doc/integral_promotion.qbk
 /trunk/libs/type_traits/doc/intrinsics.qbk
 /trunk/libs/type_traits/doc/is_abstract.qbk
 /trunk/libs/type_traits/doc/is_arithmetic.qbk
 /trunk/libs/type_traits/doc/is_array.qbk
 /trunk/libs/type_traits/doc/is_base_of.qbk
 /trunk/libs/type_traits/doc/is_class.qbk
 /trunk/libs/type_traits/doc/is_complex.qbk
 /trunk/libs/type_traits/doc/is_compound.qbk
 /trunk/libs/type_traits/doc/is_const.qbk
 /trunk/libs/type_traits/doc/is_convertible.qbk
 /trunk/libs/type_traits/doc/is_empty.qbk
 /trunk/libs/type_traits/doc/is_enum.qbk
 /trunk/libs/type_traits/doc/is_floating_point.qbk
 /trunk/libs/type_traits/doc/is_function.qbk
 /trunk/libs/type_traits/doc/is_fundamental.qbk
 /trunk/libs/type_traits/doc/is_integral.qbk
 /trunk/libs/type_traits/doc/is_member_function_pointer.qbk
 /trunk/libs/type_traits/doc/is_member_object_pointer.qbk
 /trunk/libs/type_traits/doc/is_member_pointer.qbk
 /trunk/libs/type_traits/doc/is_object.qbk
 /trunk/libs/type_traits/doc/is_pod.qbk
 /trunk/libs/type_traits/doc/is_pointer.qbk
 /trunk/libs/type_traits/doc/is_polymorphic.qbk
 /trunk/libs/type_traits/doc/is_reference.qbk
 /trunk/libs/type_traits/doc/is_same.qbk
 /trunk/libs/type_traits/doc/is_scalar.qbk
 /trunk/libs/type_traits/doc/is_signed.qbk
 /trunk/libs/type_traits/doc/is_stateless.qbk
 /trunk/libs/type_traits/doc/is_union.qbk
 /trunk/libs/type_traits/doc/is_unsigned.qbk
 /trunk/libs/type_traits/doc/is_virtual_base_of.qbk
 /trunk/libs/type_traits/doc/is_void.qbk
 /trunk/libs/type_traits/doc/is_volatile.qbk
 /trunk/libs/type_traits/doc/make_signed.qbk
 /trunk/libs/type_traits/doc/make_unsigned.qbk
 /trunk/libs/type_traits/doc/mpl.qbk
 /trunk/libs/type_traits/doc/promote.qbk
 /trunk/libs/type_traits/doc/rank.qbk
 /trunk/libs/type_traits/doc/remove_all_extents.qbk
 /trunk/libs/type_traits/doc/remove_const.qbk
 /trunk/libs/type_traits/doc/remove_cv.qbk
 /trunk/libs/type_traits/doc/remove_extent.qbk
 /trunk/libs/type_traits/doc/remove_pointer.qbk
 /trunk/libs/type_traits/doc/remove_reference.qbk
 /trunk/libs/type_traits/doc/remove_volatile.qbk
 /trunk/libs/type_traits/doc/transform_traits.qbk
 /trunk/libs/type_traits/doc/type_traits.qbk
 /trunk/libs/type_traits/doc/type_with_alignment.qbk
 /trunk/libs/type_traits/doc/user_defined.qbk
 /trunk/libs/type_traits/doc/value_traits.qbk
Modified:
 /trunk/libs/unordered/doc/changes.qbk
 /trunk/libs/unordered/doc/ref.xml
 /trunk/libs/unordered/examples/case_insensitive.hpp
 /trunk/libs/unordered/examples/case_insensitive_test.cpp
 /trunk/libs/unordered/examples/fnv1.hpp
 /trunk/libs/wave/doc/acknowledgements.html
 /trunk/libs/wave/doc/class_ref_ctxpolicy_depr.html
 /trunk/libs/wave/doc/class_reference_context.html
 /trunk/libs/wave/doc/class_reference_ctxpolicy.html
 /trunk/libs/wave/doc/class_reference_filepos.html
 /trunk/libs/wave/doc/class_reference_inptpolcy.html
 /trunk/libs/wave/doc/class_reference_lexer.html
 /trunk/libs/wave/doc/class_reference_tokentype.html
 /trunk/libs/wave/doc/compiletime_config.html
 /trunk/libs/wave/doc/introduction.html
 /trunk/libs/wave/doc/macro_expansion_process.html
 /trunk/libs/wave/doc/predefined_macros.html
 /trunk/libs/wave/doc/preface.html
 /trunk/libs/wave/doc/quickstart.html
 /trunk/libs/wave/doc/references.html
 /trunk/libs/wave/doc/samples.html
 /trunk/libs/wave/doc/supported_pragmas.html
 /trunk/libs/wave/doc/token_ids.html
 /trunk/libs/wave/doc/tracing_facility.html
 /trunk/libs/wave/doc/wave_driver.html

=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/Jamfile.v2      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,69 @@
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# 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)
+
+using quickbook ;
+
+path-constant boost-images : ../../../doc/src/images ;
+
+xml type_traits : type_traits.qbk ;
+boostbook standalone
+    :
+        type_traits
+    :
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+        # Path for libraries index:
+        <xsl:param>boost.libraries=../../../libraries.htm
+        # Use the main Boost stylesheet:
+        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+
+        # Some general style settings:
+        <xsl:param>table.footnote.number.format=1
+        <xsl:param>footnote.number.format=1
+
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=10
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=1
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=10
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=4
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=10
+
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        <xsl:param>xep.extensions=1
+ # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Paper type = A4
+        <xsl:param>paper.type=A4
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/type_traits/doc/html
+    ;
+
+#install html : ../../../doc/html/boostbook.css ;
+#install ../ : ../../../boost.png ;
+
+
+
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/add_const.qbk   Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:add_const add_const]
+
+   template <class T>
+   struct add_const
+   {
+      typedef __below type;
+   };
+
+__type The same type as `T const` for all `T`.
+
+__std_ref 3.9.3.
+
+__compat If the compiler does not support partial specialization of class-templates +then this template will compile, but the member `type` will always be the same as
+type `T` except where __transform_workaround have been applied.
+
+__header ` #include <boost/type_traits/add_const.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_const<int>::type`][`int const`]]
+
+[[`add_const<int&>::type`] [`int&`]]
+
+[[`add_const<int*>::type`] [`int* const`]]
+
+[[`add_const<int const>::type`] [`int const`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/add_cv.qbk      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:add_cv add_cv]
+
+   template <class T>
+   struct add_cv
+   {
+      typedef __below type;
+   };
+
+__type The same type as `T const volatile` for all `T`.
+
+__std_ref 3.9.3.
+
+__compat If the compiler does not support partial specialization of class-templates +then this template will compile, but the member `type` will always be the same as
+type `T` except where __transform_workaround have been applied.
+
+__header ` #include <boost/type_traits/add_cv.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_cv<int>::type`][`int const volatile`]]
+
+[[`add_cv<int&>::type`] [`int&`]]
+
+[[`add_cv<int*>::type`] [`int* const volatile`]]
+
+[[`add_cv<int const>::type`] [`int const volatile`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/add_pointer.qbk Mon Feb  8 22:59:49 2010
@@ -0,0 +1,45 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:add_pointer add_pointer]
+
+   template <class T>
+   struct add_pointer
+   {
+      typedef __below type;
+   };
+
+__type The same type as `remove_reference<T>::type*`.
+
+The rationale for this template
+is that it produces the same type as `TYPEOF(&t)`,
+where `t` is an object of type `T`.
+
+__std_ref 8.3.1.
+
+__compat If the compiler does not support partial specialization of class-templates +then this template will compile, but the member `type` will always be the same as
+type `T` except where __transform_workaround have been applied.
+
+__header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_pointer<int>::type`][`int*`]]
+
+[[`add_pointer<int const&>::type`] [`int const*`]]
+
+[[`add_pointer<int*>::type`] [`int**`]]
+
+[[`add_pointer<int*&>::type`] [`int**`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/add_reference.qbk       Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:add_reference add_reference]
+
+   template <class T>
+   struct add_reference
+   {
+      typedef __below type;
+   };
+
+__type If `T` is not a reference type then `T&`, otherwise `T`.
+
+__std_ref 8.3.2.
+
+__compat If the compiler does not support partial specialization of class-templates +then this template will compile, but the member `type` will always be the same as
+type `T` except where __transform_workaround have been applied.
+
+__header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_reference<int>::type`][`int&`]]
+
+[[`add_reference<int const&>::type`] [`int const&`]]
+
+[[`add_reference<int*>::type`] [`int*&`]]
+
+[[`add_reference<int*&>::type`] [`int*&`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/add_volatile.qbk        Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:add_volatile add_volatile]
+
+   template <class T>
+   struct add_volatile
+   {
+      typedef __below type;
+   };
+
+__type The same type as `T volatile` for all `T`.
+
+__std_ref 3.9.3.
+
+__compat If the compiler does not support partial specialization of class-templates +then this template will compile, but the member `type` will always be the same as
+type `T` except where __transform_workaround have been applied.
+
+__header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_volatile<int>::type`][`int volatile`]]
+
+[[`add_volatile<int&>::type`] [`int&`]]
+
+[[`add_volatile<int*>::type`] [`int* volatile`]]
+
+[[`add_volatile<int const>::type`] [`int const volatile`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/aligned_storage.qbk     Mon Feb  8 22:59:49 2010
@@ -0,0 +1,22 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:aligned_storage aligned_storage]
+
+   template <std::size_t Size, std::size_t Align>
+   struct aligned_storage
+   {
+      typedef __below type;
+   };
+
+__type a built-in or POD type with size `Size` and an alignment
+that is a multiple of `Align`.
+
+__header ` #include <boost/type_traits/aligned_storage.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/alignment_of.qbk        Mon Feb  8 22:59:49 2010
@@ -0,0 +1,34 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:alignment_of alignment_of]
+   template <class T>
+ struct alignment_of : public __integral_constant<std::size_t, ALIGNOF(T)> {};
+
+__inherit Class template `alignment_of` inherits from
+`__integral_constant<std::size_t, ALIGNOF(T)>`, where `ALIGNOF(T)` is the
+alignment of type T.
+
+['Note: strictly speaking you should only rely on
+the value of `ALIGNOF(T)` being a multiple of the true alignment of T, although +in practice it does compute the correct value in all the cases we know about.]
+
+__header ` #include <boost/type_traits/alignment_of.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`alignment_of<int>` inherits from `__integral_constant<std::size_t, ALIGNOF(int)>`.]
+
+[:`alignment_of<char>::type` is the type `__integral_constant<std::size_t, ALIGNOF(char)>`.]
+
+[:`alignment_of<double>::value` is an integral constant
+expression with value `ALIGNOF(double)`.]
+
+[:`alignment_of<T>::value_type` is the type `std::size_t`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/alignment_traits.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,24 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:alignment Synthesizing Types with Specific Alignments]
+
+Some low level memory management routines need to synthesize a POD type with +specific alignment properties. The template `__type_with_alignment` finds the smallest +type with a specified alignment, while template `__aligned_storage` creates a type
+with a specific size and alignment.
+
+[*Synopsis]
+
+   template <std::size_t Align>
+   struct __type_with_alignment;
+
+   template <std::size_t Size, std::size_t Align>
+   struct __aligned_storage;
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/background.qbk  Mon Feb  8 22:59:49 2010
@@ -0,0 +1,322 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:background Background and Tutorial]
+
+The following is an updated version of the article "C++ Type traits"
+by John Maddock and Steve Cleary that appeared in the October 2000
+issue of [@http://www.ddj.com Dr Dobb's Journal].
+
+Generic programming (writing code which works with any data type meeting a
+set of requirements) has become the method of choice for providing reusable code.
+However, there are times in generic programming when "generic" just isn't
+good enough - sometimes the differences between types are too large for an
+efficient generic implementation. This is when the traits technique
+becomes important - by encapsulating those properties that need to be
+considered on a type by type basis inside a traits class, we can
+minimize the amount of code that has to differ from one type to another,
+and maximize the amount of generic code.
+
+Consider an example: when working with character strings, one common operation is +to determine the length of a null terminated string. Clearly it's possible to +write generic code that can do this, but it turns out that there are much more +efficient methods available: for example, the C library functions `strlen` and +`wcslen` are usually written in assembler, and with suitable hardware support
+can be considerably faster than a generic version written in C++.
+The authors of the C++ standard library realized this, and abstracted the
+properties of `char` and `wchar_t` into the class `char_traits`. Generic code
+that works with character strings can simply use `char_traits<>::length` to
+determine the length of a null terminated string, safe in the knowledge
+that specializations of `char_traits` will use the most appropriate method
+available to them.
+
+[h4 Type Traits]
+
+Class `char_traits` is a classic example of a collection of type specific
+properties wrapped up in a single class - what Nathan Myers termed a
+/baggage class/[link background.references \[1\]]. In the Boost type-traits library, we[link background.references \[2\]] have written a +set of very specific traits classes, each of which encapsulate a single trait +from the C++ type system; for example, is a type a pointer or a reference type?
+Or does a type have a trivial constructor, or a const-qualifier?
+The type-traits classes share a unified design: each class inherits from a
+the type __true_type if the type has the specified property and inherits from
+__false_type otherwise. As we will show, these classes can be used in
+generic programming to determine the properties of a given type and introduce
+optimizations that are appropriate for that case.
+
+The type-traits library also contains a set of classes that perform a
+specific transformation on a type; for example, they can remove a
+top-level const or volatile qualifier from a type. Each class that
+performs a transformation defines a single typedef-member `type`
+that is the result of the transformation. All of the type-traits
+classes are defined inside namespace `boost`; for brevity, namespace-qualification
+is omitted in most of the code samples given.
+
+[h4 Implementation]
+
+There are far too many separate classes contained in the type-traits library +to give a full implementation here - see the source code in the Boost library +for the full details - however, most of the implementation is fairly repetitive +anyway, so here we will just give you a flavor for how some of the classes are
+implemented. Beginning with possibly the simplest class in the library,
+`is_void<T>` inherits from `__true_type` only if `T` is `void`.
+
+   template <typename T>
+   struct __is_void : public __false_type{};
+
+   template <>
+   struct __is_void<void> : public __true_type{};
+
+Here we define a primary version of the template class `__is_void`, and
+provide a full-specialization when `T` is `void`. While full specialization
+of a template class is an important technique, sometimes we need a
+solution that is halfway between a fully generic solution, and a full
+specialization. This is exactly the situation for which the standards committee
+defined partial template-class specialization. As an example, consider the
+class `boost::is_pointer<T>`: here we needed a primary version that handles
+all the cases where T is not a pointer, and a partial specialization to
+handle all the cases where T is a pointer:
+
+   template <typename T>
+   struct __is_pointer : public __false_type{};
+
+   template <typename T>
+   struct __is_pointer<T*> : public __true_type{};
+
+The syntax for partial specialization is somewhat arcane and could easily
+occupy an article in its own right; like full specialization, in order to
+write a partial specialization for a class, you must first declare the
+primary template. The partial specialization contains an extra <...> after the +class name that contains the partial specialization parameters; these define
+the types that will bind to that partial specialization rather than the
+default template. The rules for what can appear in a partial specialization
+are somewhat convoluted, but as a rule of thumb if you can legally write two
+function overloads of the form:
+
+   void foo(T);
+   void foo(U);
+
+Then you can also write a partial specialization of the form:
+
+   template <typename T>
+   class c{ /*details*/ };
+
+   template <typename T>
+   class c<U>{ /*details*/ };
+
+This rule is by no means foolproof, but it is reasonably simple to remember
+and close enough to the actual rule to be useful for everyday use.
+
+As a more complex example of partial specialization consider the class
+`remove_extent<T>`. This class defines a single typedef-member `type` that
+is the same type as T but with any top-level array bounds removed;
+this is an example of a traits class that performs a transformation on a type:
+
+   template <typename T>
+   struct __remove_extent
+   { typedef T type; };
+
+   template <typename T, std::size_t N>
+   struct __remove_extent<T[N]>
+   { typedef T type; };
+
+The aim of `__remove_extent` is this: imagine a generic algorithm that is
+passed an array type as a template parameter, `__remove_extent` provides a
+means of determining the underlying type of the array. For example
+`remove_extent<int[4][5]>::type` would evaluate to the type `int[5]`.
+This example also shows that the number of template parameters in a
+partial specialization does not have to match the number in the
+default template. However, the number of parameters that appear after the
+class name do have to match the number and type of the parameters in the
+default template.
+
+[h4 Optimized copy]
+
+As an example of how the type traits classes can be used, consider the
+standard library algorithm copy:
+
+   template<typename Iter1, typename Iter2>
+   Iter2 copy(Iter1 first, Iter1 last, Iter2 out);
+
+Obviously, there's no problem writing a generic version of copy that works
+for all iterator types `Iter1` and `Iter2`; however, there are some
+circumstances when the copy operation can best be performed by a call to
+`memcpy`. In order to implement copy in terms of `memcpy` all of the
+following conditions need to be met:
+
+* Both of the iterator types `Iter1` and `Iter2` must be pointers.
+* Both `Iter1` and `Iter2` must point to the same type - excluding const and
+volatile-qualifiers.
+* The type pointed to by `Iter1` must have a trivial assignment operator.
+
+By trivial assignment operator we mean that the type is either a scalar type[link background.references \[3\]] or:
+
+* The type has no user defined assignment operator.
+* The type does not have any data members that are references.
+* All base classes, and all data member objects must have trivial assignment operators.
+
+If all these conditions are met then a type can be copied using `memcpy`
+rather than using a compiler generated assignment operator. The type-traits
+library provides a class `__has_trivial_assign`, such that
+`has_trivial_assign<T>::value` is true only if T has a trivial assignment operator.
+This class "just works" for scalar types, but has to be explicitly
+specialised for class/struct types that also happen to have a trivial assignment
+operator. In other words if __has_trivial_assign gives the wrong answer,
+it will give the "safe" wrong answer - that trivial assignment is not allowable.
+
+The code for an optimized version of copy that uses `memcpy` where appropriate is +given in [link boost_typetraits.examples.copy the examples]. The code begins by defining a template +function `do_copy` that performs a "slow but safe" copy. The last parameter passed +to this function may be either a `__true_type` or a `__false_type`. Following that +there is an overload of do_copy that uses `memcpy`: this time the iterators are required
+to actually be pointers to the same type, and the final parameter must be a
+`__true_type`.  Finally, the version of `copy` calls `do_copy`, passing
+`__has_trivial_assign<value_type>()` as the final parameter: this will dispatch
+to the optimized version where appropriate, otherwise it will call the
+"slow but safe version".
+
+[h4 Was it worth it?]
+
+It has often been repeated in these columns that "premature optimization is the +root of all evil" [link background.references \[4\]]. So the question must be asked: was our optimization
+premature? To put this in perspective the timings for our version of copy
+compared a conventional generic copy[link background.references \[5\]] are shown in table 1.
+
+Clearly the optimization makes a difference in this case; but, to be fair,
+the timings are loaded to exclude cache miss effects - without this
+accurate comparison between algorithms becomes difficult. However, perhaps
+we can add a couple of caveats to the premature optimization rule:
+
+*If you use the right algorithm for the job in the first place then optimization
+will not be required; in some cases, memcpy is the right algorithm.
+*If a component is going to be reused in many places by many people then
+optimizations may well be worthwhile where they would not be so for a single
+case - in other words, the likelihood that the optimization will be
+absolutely necessary somewhere, sometime is that much higher.
+Just as importantly the perceived value of the stock implementation will be
+higher: there is no point standardizing an algorithm if users reject it on
+the grounds that there are better, more heavily optimized versions available.
+
+[table Time taken to copy 1000 elements using `copy<const T*, T*>` (times in micro-seconds)
+
+[[Version] [T] [Time]]
+[["Optimized" copy] [char] [0.99]]
+[[Conventional copy] [char] [8.07]]
+[["Optimized" copy] [int] [2.52]]
+[[Conventional copy] [int] [8.02]]
+]
+
+[h4 Pair of References]
+The optimized copy example shows how type traits may be used to perform
+optimization decisions at compile-time. Another important usage of type traits
+is to allow code to compile that otherwise would not do so unless excessive
+partial specialization is used. This is possible by delegating partial
+specialization to the type traits classes. Our example for this form of
+usage is a pair that can hold references [link background.references \[6\]].
+
+First, let us examine the definition of `std::pair`, omitting the
+comparison operators, default constructor, and template copy constructor for
+simplicity:
+
+   template <typename T1, typename T2>
+   struct pair
+   {
+   typedef T1 first_type;
+   typedef T2 second_type;
+
+   T1 first;
+   T2 second;
+
+   pair(const T1 & nfirst, const T2 & nsecond)
+   :first(nfirst), second(nsecond) { }
+   };
+
+Now, this "pair" cannot hold references as it currently stands, because the
+constructor would require taking a reference to a reference, which is
+currently illegal [link background.references \[7\]]. Let us consider what the constructor's parameters
+would have to be in order to allow "pair" to hold non-reference types,
+references, and constant references:
+
+[table Required Constructor Argument Types
+[[Type of `T1`] [Type of parameter to initializing constructor]]
+[[T] [const T &]]
+[[T &] [T &]]
+[[const T &] [const T &]]
+]
+
+A little familiarity with the type traits classes allows us to construct a
+single mapping that allows us to determine the type of parameter from the
+type of the contained class. The type traits classes provide a
+transformation __add_reference, which adds a reference to its type,
+unless it is already a reference.
+
+[table Using add_reference to synthesize the correct constructor type
+[[Type of `T1`] [Type of `const T1`] [Type of `add_reference<const T1>::type`]]
+[[T] [const T] [const T &]]
+[[T &] [T & \[8\]] [T &]]
+[[const T &] [const T &] [const T &]]
+]
+
+This allows us to build a primary template definition for `pair` that can
+contain non-reference types, reference types, and constant reference types:
+
+   template <typename T1, typename T2>
+   struct pair
+   {
+   typedef T1 first_type;
+   typedef T2 second_type;
+
+   T1 first;
+   T2 second;
+
+   pair(boost::__add_reference<const T1>::type nfirst,
+         boost::__add_reference<const T2>::type nsecond)
+   :first(nfirst), second(nsecond) { }
+   };
+
+Add back in the standard comparison operators, default constructor,
+and template copy constructor (which are all the same), and you have a
+`std::pair` that can hold reference types!
+
+This same extension could have been done using partial template specialization
+of `pair`, but to specialize `pair` in this way would require three partial
+specializations, plus the primary template. Type traits allows us to
+define a single primary template that adjusts itself auto-magically to
+any of these partial specializations, instead of a brute-force partial
+specialization approach. Using type traits in this fashion allows
+programmers to delegate partial specialization to the type traits classes,
+resulting in code that is easier to maintain and easier to understand.
+
+[h4 Conclusion]
+
+We hope that in this article we have been able to give you some idea of
+what type-traits are all about. A more complete listing of the available
+classes are in the boost documentation, along with further examples using
+type traits. Templates have enabled C++ uses to take the advantage of the
+code reuse that generic programming brings; hopefully this article has
+shown that generic programming does not have to sink to the lowest common
+denominator, and that templates can be optimal as well as generic.
+
+[h4 Acknowledgements]
+
+The authors would like to thank Beman Dawes and Howard Hinnant for their
+helpful comments when preparing this article.
+
+[h4 [#background.references]References]
+
+# Nathan C. Myers, C++ Report, June 1995.
+# The type traits library is based upon contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org. +# A scalar type is an arithmetic type (i.e. a built-in integer or floating point type), an enumeration type, a pointer, a pointer to member, or a const- or volatile-qualified version of one of these types. +# This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg 268. +# The test code is available as part of the boost utility library (see algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all optimisations turned on, tests were conducted on a 400MHz Pentium II machine running Microsoft Windows 98. +# John Maddock and Howard Hinnant have submitted a "compressed_pair" library to Boost, which uses a technique similar to the one described here to hold references. Their pair also uses type traits to determine if any of the types are empty, and will derive instead of contain to conserve space -- hence the name "compressed". +# This is actually an issue with the C++ Core Language Working Group (issue #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow a "reference to a reference to T" to mean the same thing as a "reference to T", but only in template instantiation, in a method similar to multiple cv-qualifiers. +# For those of you who are wondering why this shouldn't be const-qualified, remember that references are always implicitly constant (for example, you can't re-assign a reference). Remember also that "const T &" is something completely different. For this reason, cv-qualifiers on template type arguments that are references are ignored.
+
+[endsect]
+
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/credits.qbk     Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:credits Credits]
+
+This documentation was pulled together by John Maddock, using
+[@../../../../doc/html/quickbook.html Boost.Quickbook]
+and [@../../../../doc/html/boostbook.html Boost.DocBook].
+
+The original version of this library was created by Steve Cleary,
+Beman Dawes, Howard Hinnant, and John Maddock.  John Maddock is the
+current maintainer of the library.
+
+This version of type traits library is based on contributions by
+Adobe Systems Inc, David Abrahams, Steve Cleary,
+Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus,
+Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek.
+
+Mat Marcus and Jesse Jones invented, and
+[@http://opensource.adobe.com/project4/project.shtml published a paper describing],
+the partial specialization workarounds used in this library.
+
+Aleksey Gurtovoy added MPL integration to the library.
+
+The __is_convertible template is based on code originally devised by
+Andrei Alexandrescu, see
+"[@http://www.cuj.com/experts/1810/alexandr.htm?topic=experts
+Generic<Programming>: Mappings between Types and Values]".
+
+The latest version of this library and documentation can be found at
+[@http://www.boost.org www.boost.org]. Bugs, suggestions and discussion
+should be directed to boost@xxxxxxxxxxxxxxx
+(see [@http://www.boost.org/more/mailing_lists.htm#main
+www.boost.org/more/mailing_lists.htm#main] for subscription details).
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/decay.qbk       Mon Feb  8 22:59:49 2010
@@ -0,0 +1,40 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:decay decay]
+
+   template <class T>
+   struct decay
+   {
+      typedef __below type;
+   };
+
+__type Let `U` be the result of `remove_reference<T>::type`, then if `U` is
+an array type, the result is `remove_extent<U>::type*`, otherwise if `U` is a
+function type then the result is `U*`, otherwise the result is `U`.
+
+__std_ref 3.9.1.
+
+__header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`decay<int[2][3]>::type`][`int[3]*`]]
+
+[[`decay<int(&)[2]>::type`] [`int*`]]
+
+[[`decay<int(&)(double)>::type`] [`int(*)(double)`]]
+
+[[`int(*)(double`] [`int(*)(double)`]]
+[[`int(double)`] [`int(*)(double)`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/decomposing_func.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,20 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:function Decomposing Function Types]
+
+The class template __function_traits extracts information from function types +(see also __is_function). This traits class allows you to tell how many arguments +a function takes, what those argument types are, and what the return type is.
+
+[*Synopsis]
+
+   template <std::size_t Align>
+   struct __function_traits;
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/examples.qbk    Mon Feb  8 22:59:49 2010
@@ -0,0 +1,220 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:examples Examples]
+
+[section:copy An Optimized Version of std::copy]
+
+Demonstrates a version of `std::copy` that uses `__has_trivial_assign` to
+determine whether to use `memcpy` to optimise the copy operation
+(see [@../../examples/copy_example.cpp copy_example.cpp]):
+
+   //
+   // opt::copy
+   // same semantics as std::copy
+   // calls memcpy where appropriate.
+   //
+
+   namespace detail{
+
+   template<typename I1, typename I2, bool b>
+ I2 copy_imp(I1 first, I1 last, I2 out, const boost::__integral_constant<bool, b>&)
+   {
+      while(first != last)
+      {
+         *out = *first;
+         ++out;
+         ++first;
+      }
+      return out;
+   }
+
+   template<typename T>
+ T* copy_imp(const T* first, const T* last, T* out, const boost::__true_type&)
+   {
+      memcpy(out, first, (last-first)*sizeof(T));
+      return out+(last-first);
+   }
+
+
+   }
+
+   template<typename I1, typename I2>
+   inline I2 copy(I1 first, I1 last, I2 out)
+   {
+      //
+      // We can copy with memcpy if T has a trivial assignment operator,
+      // and if the iterator arguments are actually pointers (this last
+      // requirement we detect with overload resolution):
+      //
+      typedef typename std::iterator_traits<I1>::value_type value_type;
+ return detail::copy_imp(first, last, out, boost::__has_trivial_assign<value_type>());
+   }
+
+
+[endsect]
+
+[section:fill An Optimised Version of std::fill]
+
+Demonstrates a version of `std::fill` that uses `__has_trivial_assign` to
+determine whether to use `memset` to optimise the fill operation
+(see [@../../examples/fill_example.cpp fill_example.cpp]):
+
+   //
+   // fill
+   // same as std::fill, but uses memset where appropriate
+   //
+   namespace detail{
+
+   template <typename I, typename T, bool b>
+ void do_fill(I first, I last, const T& val, const boost::__integral_constant<bool, b>&)
+   {
+      while(first != last)
+      {
+         *first = val;
+         ++first;
+      }
+   }
+
+   template <typename T>
+   void do_fill(T* first, T* last, const T& val, const boost::__true_type&)
+   {
+      std::memset(first, val, last-first);
+   }
+
+   }
+
+   template <class I, class T>
+   inline void fill(I first, I last, const T& val)
+   {
+      //
+      // We can do an optimised fill if T has a trivial assignment
+      // operator and if it's size is one:
+      //
+      typedef boost::__integral_constant<bool,
+ ::boost::__has_trivial_assign<T>::value && (sizeof(T) == 1)> truth_type;
+      detail::do_fill(first, last, val, truth_type());
+   }
+
+
+[endsect]
+
+[section:destruct An Example that Omits Destructor Calls For Types with Trivial Destructors]
+
+Demonstrates a simple algorithm that uses `__has_trivial_destruct` to
+determine whether to destructors need to be called
+(see [@../../examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]):
+
+   //
+   // algorithm destroy_array:
+   // The reverse of std::unitialized_copy, takes a block of
+   // initialized memory and calls destructors on all objects therein.
+   //
+
+   namespace detail{
+
+   template <class T>
+   void do_destroy_array(T* first, T* last, const boost::__false_type&)
+   {
+      while(first != last)
+      {
+         first->~T();
+         ++first;
+      }
+   }
+
+   template <class T>
+ inline void do_destroy_array(T* first, T* last, const boost::__true_type&)
+   {
+   }
+
+   } // namespace detail
+
+   template <class T>
+   inline void destroy_array(T* p1, T* p2)
+   {
+ detail::do_destroy_array(p1, p2, ::boost::__has_trivial_destructor<T>());
+   }
+
+
+[endsect]
+
+[section:iter An improved Version of std::iter_swap]
+
+Demonstrates a version of `std::iter_swap` that use type traits to
+determine whether an it's arguments are proxying iterators or not,
+if they're not then it just does a `std::swap` of it's dereferenced
+arguments (the
+same as `std::iter_swap` does), however if they are proxying iterators
+then takes special care over the swap to ensure that the algorithm
+works correctly for both proxying iterators, and even iterators of
+different types
+(see [@../../examples/iter_swap_example.cpp iter_swap_example.cpp]):
+
+   //
+   // iter_swap:
+   // tests whether iterator is a proxying iterator or not, and
+   // uses optimal form accordingly:
+   //
+   namespace detail{
+
+   template <typename I>
+   static void do_swap(I one, I two, const boost::__false_type&)
+   {
+      typedef typename std::iterator_traits<I>::value_type v_t;
+      v_t v = *one;
+      *one = *two;
+      *two = v;
+   }
+   template <typename I>
+   static void do_swap(I one, I two, const boost::__true_type&)
+   {
+      using std::swap;
+      swap(*one, *two);
+   }
+
+   }
+
+   template <typename I1, typename I2>
+   inline void iter_swap(I1 one, I2 two)
+   {
+      //
+      // See is both arguments are non-proxying iterators,
+      // and if both iterator the same type:
+      //
+      typedef typename std::iterator_traits<I1>::reference r1_t;
+      typedef typename std::iterator_traits<I2>::reference r2_t;
+
+      typedef boost::__integral_constant<bool,
+         ::boost::__is_reference<r1_t>::value
+         && ::boost::__is_reference<r2_t>::value
+         && ::boost::__is_same<r1_t, r2_t>::value> truth_type;
+
+      detail::do_swap(one, two, truth_type());
+   }
+
+
+[endsect]
+
+[section:to_double Convert Numeric Types and Enums to double]
+
+Demonstrates a conversion of
+[@../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types
+Numeric Types]
+and enum types to double:
+
+    template<class T>
+    inline double to_double(T const& value)
+    {
+        typedef typename boost::promote<T>::type promoted;
+        return boost::numeric::converter<double,promoted>::convert(value);
+    }
+
+[endsect]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/extent.qbk      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:extent extent]
+   template <class T, std::size_t N = 0>
+   struct extent : public __integral_constant<std::size_t, EXTENT(T,N)> {};
+
+__inherit Class template extent inherits from `__integral_constant<std::size_t, EXTENT(T,N)>`, +where `EXTENT(T,N)` is the number of elements in the N'th array dimention of type `T`.
+
+If `T` is not an array type, or if `N > __rank<T>::value`, or if the N'th array bound
+is incomplete, then `EXTENT(T,N)` is zero.
+
+__header ` #include <boost/type_traits/extent.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`extent<int[1]>` inherits from `__integral_constant<std::size_t, 1>`.]
+
+[:`extent<double[2][3][4], 1>::type` is the type `__integral_constant<std::size_t, 3>`.]
+
+[:`extent<int[4]>::value` is an integral constant
+expression that evaluates to /4/.]
+
+[:`extent<int[][2]>::value` is an integral constant
+expression that evaluates to /0/.]
+
+[:`extent<int[][2], 1>::value` is an integral constant
+expression that evaluates to /2/.]
+
+[:`extent<int*>::value` is an integral constant
+expression that evaluates to /0/.]
+
+[:`extent<T>::value_type` is the type `std::size_t`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/floating_point_promotion.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,37 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:floating_point_promotion floating_point_promotion]
+
+   template <class T>
+   struct floating_point_promotion
+   {
+      typedef __below type;
+   };
+
+__type If floating point promotion can be applied to an rvalue of type `T`,
+then applies floating point promotion to `T` and keeps cv-qualifiers of `T`,
+otherwise leaves `T` unchanged.
+
+__std_ref 4.6.
+
+__header ` #include <boost/type_traits/floating_point_promotion.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`floating_point_promotion<float const>::type`][`double const`]]
+
+[[`floating_point_promotion<float&>::type`][`float&`]]
+
+[[`floating_point_promotion<short>::type`][`short`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/function_traits.qbk     Mon Feb  8 22:59:49 2010
@@ -0,0 +1,56 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:function_traits function_traits]
+[def __argN '''arg<replaceable>N</replaceable>_type''']
+
+   template <class F>
+   struct function_traits
+   {
+      static const std::size_t    arity = __below;
+      typedef __below           result_type;
+      typedef __below           __argN;
+   };
+
+The class template function_traits will only compile if:
+
+* The compiler supports partial specialization of class templates.
+* The template argument `F` is a /function type/, note that this ['[*is not]]
+the same thing as a /pointer to a function/.
+
+[tip
+function_traits is intended to introspect only C++ functions of the
+form R (), R( A1 ), R ( A1, ... etc. ) and not function pointers or
+class member functions. To convert a function pointer type to a suitable
+type use __remove_pointer.]
+
+[table Function Traits Members
+[[Member] [Description]]
+[[`function_traits<F>::arity`]
+ [An integral constant expression that gives the number of arguments accepted by the function type `F`.]]
+[[`function_traits<F>::result_type`]
+   [The type returned by function type `F`.]]
+[[`function_traits<F>::__argN`]
+ [The '''<replaceable>N</replaceable>th''' argument type of function type `F`, where `1 <= N <= arity` of `F`.]]
+]
+
+[table Examples
+[[Expression] [Result]]
+[[`function_traits<void (void)>::arity`] [An integral constant expression that has the value 0.]] +[[`function_traits<long (int)>::arity`] [An integral constant expression that has the value 1.]] +[[`function_traits<long (int, long, double, void*)>::arity`] [An integral constant expression that has the value 4.]]
+[[`function_traits<void (void)>::result_type`] [The type `void`.]]
+[[`function_traits<long (int)>::result_type`] [The type `long`.]]
+[[`function_traits<long (int)>::arg1_type`] [The type `int`.]]
+[[`function_traits<long (int, long, double, void*)>::arg4_type`] [The type `void*`.]] +[[`function_traits<long (int, long, double, void*)>::arg5_type`] [A compiler error: there is no `arg5_type` since there are only four arguments.]] +[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_new_operator.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,49 @@
+[/
+  Copyright 2009 John Maddock.
+  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).
+]
+
+[section:has_new_operator has_new_operator]
+   template <class T>
+   struct has_new_operator : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with an overloaded new-operator
+then inherits from __true_type, otherwise inherits from __false_type.
+
+__compat Not usable with compilers that do not support "substitution failure is not an error" +(in which case BOOST_NO_SFINAE will be defined), also known to be broken with
+the Borland/Codegear compiler.
+
+__std_ref 12.5.
+
+__header ` #include <boost/type_traits/has_new_operator.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+Given:
+
+       class A { void* operator new(std::size_t); };
+       class B { void* operator new(std::size_t, const std::nothrow&); };
+       class C { void* operator new(std::size_t, void*); };
+       class D { void* operator new[](std::size_t); };
+       class E { void* operator new[](std::size_t, const std::nothrow&); };
+       class F { void* operator new[](std::size_t, void*); };
+
+Then:
+
+[:`has_new_operator<A>` inherits from `__true_type`.]
+
+[:`has_new_operator<B>` inherits from `__true_type`.]
+
+[:`has_new_operator<C>` inherits from `__true_type`.]
+
+[:`has_new_operator<D>` inherits from `__true_type`.]
+
+[:`has_new_operator<E>` inherits from `__true_type`.]
+
+[:`has_new_operator<F>` inherits from `__true_type`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_nothrow_assign.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,29 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_nothrow_assign has_nothrow_assign]
+
+   template <class T>
+   struct has_nothrow_assign : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a non-throwing assignment-operator +then inherits from __true_type, otherwise inherits from __false_type. Type `T`
+must be a complete type.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+`has_nothrow_assign` will never report that a class or struct has a
+non-throwing assignment-operator; this is always safe, if possibly sub-optimal. +Currently (May 2005) only Visual C++ 8 has the necessary compiler support to ensure that this
+trait "just works".
+
+__header ` #include <boost/type_traits/has_nothrow_assign.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_nothrow_constructor.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,34 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_nothrow_constructor has_nothrow_constructor]
+
+   template <class T>
+   struct has_nothrow_constructor : public __tof {};
+
+   template <class T>
+   struct has_nothrow_default_constructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a non-throwing default-constructor +then inherits from __true_type, otherwise inherits from __false_type. Type `T`
+must be a complete type.
+
+These two traits are synonyms for each other.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+`has_nothrow_constructor` will never report that a class or struct has a
+non-throwing default-constructor; this is always safe, if possibly sub-optimal. +Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
+trait "just works".
+
+__header ` #include <boost/type_traits/has_nothrow_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_nothrow_copy.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,34 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_nothrow_copy has_nothrow_copy]
+
+   template <class T>
+   struct has_nothrow_copy : public __tof {};
+
+   template <class T>
+   struct has_nothrow_copy_constructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a non-throwing copy-constructor +then inherits from __true_type, otherwise inherits from __false_type. Type `T`
+must be a complete type.
+
+These two traits are synonyms for each other.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+`has_nothrow_copy` will never report that a class or struct has a
+non-throwing copy-constructor; this is always safe, if possibly sub-optimal. +Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
+trait "just works".
+
+__header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_trivial_assign.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,47 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_trivial_assign has_trivial_assign]
+   template <class T>
+   struct has_trivial_assign : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a trivial assignment-operator
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial assignment-operator then the operator has the same effect
+as copying the bits of one object to the other:
+calls to the operator can be safely replaced with a call to `memcpy`.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+has_trivial_assign will never report that a user-defined class or struct has a +trivial constructor; this is always safe, if possibly sub-optimal. Currently +(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
+user-defined classes with trivial constructors.
+
+__std_ref 12.8p11.
+
+__header ` #include <boost/type_traits/has_trivial_assign.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_assign<int>` inherits from `__true_type`.]
+
+[:`has_trivial_assign<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_assign<int (*)(long)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`has_trivial_assign<MyClass>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`has_trivial_assign<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_trivial_constructor.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,55 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_trivial_constructor has_trivial_constructor]
+
+   template <class T>
+   struct has_trivial_constructor : public __tof {};
+
+   template <class T>
+   struct has_trivial_default_constructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a trivial default-constructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+These two traits are synonyms for each other.
+
+If a type has a trivial default-constructor then the constructor have no effect: +calls to the constructor can be safely omitted. Note that using meta-programming +to omit a call to a single trivial-constructor call is of no benefit whatsoever. +However, if loops and/or exception handling code can also be omitted, then some
+benefit in terms of code size and speed can be obtained.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+has_trivial_constructor will never report that a user-defined class or struct has a +trivial constructor; this is always safe, if possibly sub-optimal. Currently +(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
+user-defined classes with trivial constructors.
+
+__std_ref 12.1p6.
+
+__header ` #include <boost/type_traits/has_trivial_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_constructor<int>` inherits from `__true_type`.]
+
+[:`has_trivial_constructor<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_constructor<int (*)(long)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`has_trivial_constructor<MyClass>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`has_trivial_constructor<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_trivial_copy.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,53 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_trivial_copy has_trivial_copy]
+
+   template <class T>
+   struct has_trivial_copy : public __tof {};
+
+   template <class T>
+   struct has_trivial_copy_constructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a trivial copy-constructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+These two traits are synonyms for each other.
+
+If a type has a trivial copy-constructor then the constructor has the same effect
+as copying the bits of one object to the other:
+calls to the constructor can be safely replaced with a call to `memcpy`.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+has_trivial_copy will never report that a user-defined class or struct has a +trivial constructor; this is always safe, if possibly sub-optimal. Currently +(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
+user-defined classes with trivial constructors.
+
+__std_ref 12.8p6.
+
+__header ` #include <boost/type_traits/has_trivial_copy.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_copy<int>` inherits from `__true_type`.]
+
+[:`has_trivial_copy<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_copy<int (*)(long)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`has_trivial_copy<MyClass>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`has_trivial_copy<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_trivial_destructor.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,49 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_trivial_destructor has_trivial_destructor]
+   template <class T>
+   struct has_trivial_destructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a trivial destructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial destructor then the destructor has no effect:
+calls to the destructor can be safely omitted. Note that using meta-programming +to omit a call to a single trivial-constructor call is of no benefit whatsoever. +However, if loops and/or exception handling code can also be omitted, then some
+benefit in terms of code size and speed can be obtained.
+
+__compat If the compiler does not support partial-specialization of class
+templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler,
+has_trivial_destructor will never report that a user-defined class or struct has a +trivial destructor; this is always safe, if possibly sub-optimal. Currently +(May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
+user-defined classes with trivial constructors.
+
+__std_ref 12.4p3.
+
+__header ` #include <boost/type_traits/has_trivial_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_destructor<int>` inherits from `__true_type`.]
+
+[:`has_trivial_destructor<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_destructor<int (*)(long)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`has_trivial_destructor<MyClass>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`has_trivial_destructor<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/has_virtual_destructor.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,28 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:has_virtual_destructor has_virtual_destructor]
+   template <class T>
+   struct has_virtual_destructor : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) type with a virtual destructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+__compat This trait is provided for completeness, since it's part of the
+Technical Report on C++ Library Extensions.  However, there is currently no
+way to portably implement this trait.  The default version provided
+always inherits from __false_type, and has to be explicitly specialized for
+types with virtual destructors unless the compiler used has compiler __intrinsics +that enable the trait to do the right thing: currently (May 2005) only Visual C++
+8 and GCC-4.3 have the necessary __intrinsics.
+
+__std_ref 12.4.
+
+__header ` #include <boost/type_traits/has_virtual_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/history.qbk     Mon Feb  8 22:59:49 2010
@@ -0,0 +1,16 @@
+[/
+  Copyright 2009 John Maddock.
+  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).
+]
+
+[section:history History]
+
+[h4 Boost 1.42.0]
+
+* Fixed issue [@https://svn.boost.org/trac/boost/ticket/3704 #3704].
+
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/integral_constant.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,26 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:integral_constant integral_constant]
+   template <class T, T val>
+   struct integral_constant
+   {
+      typedef integral_constant<T, val>  type;
+      typedef T                          value_type;
+      static const T value = val;
+   };
+
+   typedef integral_constant<bool, true>  true_type;
+   typedef integral_constant<bool, false> false_type;
+
+Class template `integral_constant` is the common base class for all the value-based +type traits. The two typedef's `true_type` and `false_type` are provided for +convenience: most of the value traits are Boolean properties and so will inherit from
+one of these.
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/integral_promotion.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,37 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:integral_promotion integral_promotion]
+
+   template <class T>
+   struct integral_promotion
+   {
+      typedef __below type;
+   };
+
+__type If integral promotion can be applied to an rvalue of type `T`, then
+applies integral promotion to `T` and keeps cv-qualifiers of `T`,
+otherwise leaves `T` unchanged.
+
+__std_ref 4.5 except 4.5/3 (integral bit-field).
+
+__header ` #include <boost/type_traits/integral_promotion.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`integral_promotion<short const>::type`][`int const`]]
+
+[[`integral_promotion<short&>::type`][`short&`]]
+
+[[`integral_promotion<enum std::float_round_style>::type`][`int`]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/intrinsics.qbk  Mon Feb  8 22:59:49 2010
@@ -0,0 +1,72 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:intrinsics Support for Compiler Intrinsics]
+
+There are some traits that can not be implemented within the current C++ language: +to make these traits "just work" with user defined types, some kind of additional +help from the compiler is required. Currently (April 2008) Visual C++ 8 and 9,
+GNU GCC 4.3 and MWCW 9
+provide the necessary intrinsics, and other compilers will no doubt follow in due
+course.
+
+The Following traits classes always need compiler support to do the right thing
+for all types
+(but all have safe fallback positions if this support is unavailable):
+
+* __is_union
+* __is_pod
+* __has_trivial_constructor
+* __has_trivial_copy
+* __has_trivial_assign
+* __has_trivial_destructor
+* __has_nothrow_constructor
+* __has_nothrow_copy
+* __has_nothrow_assign
+* __has_virtual_destructor
+
+The following traits classes can't be portably implemented in the C++ language, +although in practice, the implementations do in fact do the right thing on all
+the compilers we know about:
+
+* __is_empty
+* __is_polymorphic
+
+The following traits classes are dependent on one or more of the above:
+
+* __is_class
+* __is_stateless
+
+The hooks for compiler-intrinsic support are defined in
+[@../../../../boost/type_traits/intrinsics.hpp boost/type_traits/intrinsics.hpp], adding support for new compilers is simply
+a matter of defining one of more of the following macros:
+
+[table Macros for Compiler Intrinsics
+   [[BOOST_IS_UNION(T)][Should evaluate to true if T is a union type]]
+   [[BOOST_IS_POD(T)][Should evaluate to true if T is a POD type]]
+ [[BOOST_IS_EMPTY(T)][Should evaluate to true if T is an empty struct or union]] + [[BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)][Should evaluate to true if the default constructor for T is trivial (i.e. has no effect)]] + [[BOOST_HAS_TRIVIAL_COPY(T)][Should evaluate to true if T has a trivial copy constructor (and can therefore be replaced by a call to memcpy)]] + [[BOOST_HAS_TRIVIAL_ASSIGN(T)][Should evaluate to true if T has a trivial assignment operator (and can therefore be replaced by a call to memcpy)]] + [[BOOST_HAS_TRIVIAL_DESTRUCTOR(T)][Should evaluate to true if T has a trivial destructor (i.e. ~T() has no effect)]] + [[BOOST_HAS_NOTHROW_CONSTRUCTOR(T)][Should evaluate to true if `T x;` can not throw]] + [[BOOST_HAS_NOTHROW_COPY(T)][Should evaluate to true if `T(t)` can not throw]] + [[BOOST_HAS_NOTHROW_ASSIGN(T)][Should evaluate to true if `T t, u; t = u` can not throw]] + [[BOOST_HAS_VIRTUAL_DESTRUCTOR(T)][Should evaluate to true T has a virtual destructor]]
+
+ [[BOOST_IS_ABSTRACT(T)][Should evaluate to true if T is an abstract type]] + [[BOOST_IS_BASE_OF(T,U)][Should evaluate to true if T is a base class of U]]
+   [[BOOST_IS_CLASS(T)][Should evaluate to true if T is a class type]]
+ [[BOOST_IS_CONVERTIBLE(T,U)][Should evaluate to true if T is convertible to U]]
+   [[BOOST_IS_ENUM(T)][Should evaluate to true is T is an enum]]
+ [[BOOST_IS_POLYMORPHIC(T)][Should evaluate to true if T is a polymorphic type]] + [[BOOST_ALIGNMENT_OF(T)][Should evaluate to the alignment requirements of type T.]]
+
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_abstract.qbk Mon Feb  8 22:59:49 2010
@@ -0,0 +1,41 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_abstract is_abstract]
+   template <class T>
+   struct is_abstract : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) abstract type then inherits from
+__true_type, otherwise inherits from __false_type.
+
+__std_ref 10.3.
+
+__header ` #include <boost/type_traits/is_abstract.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat The compiler must support DR337 (as of April 2005: GCC 3.4, VC++ 7.1 (and later),
+ Intel C++ 7 (and later), and Comeau 4.3.2).
+Otherwise behaves the same as __is_polymorphic;
+this is the "safe fallback position" for which polymorphic types are always
+regarded as potentially abstract. The macro BOOST_NO_IS_ABSTRACT is used to +signify that the implementation is buggy, users should check for this in their +own code if the "safe fallback" is not suitable for their particular use-case.
+
+__examples
+
+[:Given: `class abc{ virtual ~abc() = 0; };` ]
+
+[:`is_abstract<abc>` inherits from `__true_type`.]
+
+[:`is_abstract<abc>::type` is the type `__true_type`.]
+
+[:`is_abstract<abc const>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_abstract<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_arithmetic.qbk       Mon Feb  8 22:59:49 2010
@@ -0,0 +1,32 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_arithmetic is_arithmetic]
+   template <class T>
+   struct is_arithmetic : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) arithmetic type then inherits from +__true_type, otherwise inherits from __false_type. Arithmetic types include +integral and floating point types (see also __is_integral and __is_floating_point).
+
+__std_ref 3.9.1p8.
+
+__header ` #include <boost/type_traits/is_arithmetic.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_arithmetic<int>` inherits from `__true_type`.]
+
+[:`is_arithmetic<char>::type` is the type `__true_type`.]
+
+[:`is_arithmetic<double>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_arithmetic<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_array.qbk    Mon Feb  8 22:59:49 2010
@@ -0,0 +1,35 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_array is_array]
+   template <class T>
+   struct is_array : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) array type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 8.3.4.
+
+__header ` #include <boost/type_traits/is_array.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat If the compiler does not support
+partial-specialization of class templates, then this template
+can give the wrong result with function types.
+
+__examples
+
+[:`is_array<int[2]>` inherits from `__true_type`.]
+
+[:`is_array<char[2][3]>::type` is the type `__true_type`.]
+
+[:`is_array<double[]>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_array<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_base_of.qbk  Mon Feb  8 22:59:49 2010
@@ -0,0 +1,52 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_base_of is_base_of]
+   template <class Base, class Derived>
+   struct is_base_of : public __tof {};
+
+__inherit If Base is base class of type Derived or if both types are the same
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+This template will detect non-public base classes, and ambiguous base classes.
+
+Note that `is_base_of<X,X>` will always inherit from __true_type. [*This is the
+case even if `X` is not a class type].  This is a change in behaviour
+from Boost-1.33 in order to track the Technical Report on C++ Library Extensions.
+
+Types `Base` and `Derived` must not be incomplete types.
+
+__std_ref 10.
+
+__header ` #include <boost/type_traits/is_base_of.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat If the compiler does not support partial-specialization of class templates, +then this template can not be used with function types. There are some older compilers +which will produce compiler errors if `Base` is a private base class of `Derived`, or if +`Base` is an ambiguous base of `Derived`. These compilers include Borland C++, older +versions of Sun Forte C++, Digital Mars C++, and older versions of EDG based compilers.
+
+__examples
+
+[:Given: ` class Base{}; class Derived : public Base{};` ]
+
+[:`is_base_of<Base, Derived>` inherits from `__true_type`.]
+
+[:`is_base_of<Base, Derived>::type` is the type `__true_type`.]
+
+[:`is_base_of<Base, Derived>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_base_of<Base, Base>::value` is an integral constant
+expression that evaluates to /true/: a class is regarded as it's own base.]
+
+[:`is_base_of<T, T>::value_type` is the type `bool`.]
+
+[endsect]
+
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_class.qbk    Mon Feb  8 22:59:49 2010
@@ -0,0 +1,45 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_class is_class]
+   template <class T>
+   struct is_class : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) class type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 9.2.
+
+__header ` #include <boost/type_traits/is_class.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat Without (some as yet unspecified) help from the compiler,
+we cannot distinguish between union and class types, as a result this type
+will erroneously inherit from __true_type for union types. See also __is_union. +Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to +correctly identify union types, and therefore make is_class function correctly.
+
+__examples
+
+[:Given: `class MyClass;` then:]
+
+[:`is_class<MyClass>` inherits from `__true_type`.]
+
+[:`is_class<MyClass const>::type` is the type `__true_type`.]
+
+[:`is_class<MyClass>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_class<MyClass&>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_class<MyClass*>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_class<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_complex.qbk  Mon Feb  8 22:59:49 2010
@@ -0,0 +1,21 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_complex is_complex]
+
+   template <class T>
+   struct is_complex : public __tof {};
+
+__inherit If `T` is a complex number type then true (of type `std::complex<U>` for
+some type `U`), otherwise false.
+
+__std_ref 26.2.
+
+__header ` #include <boost/type_traits/is_complex.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_compound.qbk Mon Feb  8 22:59:49 2010
@@ -0,0 +1,38 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_compound is_compound]
+   template <class T>
+   struct is_compound : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) compound type then inherits from __true_type, +otherwise inherits from __false_type. Any type that is not a fundamental type is
+a compound type (see also __is_fundamental).
+
+__std_ref 3.9.2.
+
+__header ` #include <boost/type_traits/is_compound.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_compound<MyClass>` inherits from `__true_type`.]
+
+[:`is_compound<MyEnum>::type` is the type `__true_type`.]
+
+[:`is_compound<int*>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_compound<int&>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_compound<int>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_compound<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_const.qbk    Mon Feb  8 22:59:49 2010
@@ -0,0 +1,43 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_const is_const]
+
+   template <class T>
+   struct is_const : public __tof {};
+
+__inherit If T is a (top level) const-qualified type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.3.
+
+__header ` #include <boost/type_traits/is_const.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_const<int const>` inherits from `__true_type`.]
+
+[:`is_const<int const volatile>::type` is the type `__true_type`.]
+
+[:`is_const<int* const>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_const<int const*>::value` is an integral constant
+expression that evaluates to /false/: the const-qualifier is not
+at the top level in this case.]
+
+[:`is_const<int const&>::value` is an integral constant
+expression that evaluates to /false/: the const-qualifier is not
+at the top level in this case.]
+
+[:`is_const<int>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_const<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_convertible.qbk      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,67 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_convertible is_convertible]
+   template <class From, class To>
+   struct is_convertible : public __tof {};
+
+__inherit If an imaginary lvalue of type `From` is convertible to type `To` then
+inherits from __true_type, otherwise inherits from __false_type.
+
+Type From must not be an incomplete type.
+
+Type To must not be an incomplete, or function type.
+
+No types are considered to be convertible to array types or abstract-class types.
+
+This template can not detect whether a converting-constructor is `public` or not: if +type `To` has a `private` converting constructor from type `From` then instantiating +`is_convertible<From, To>` will produce a compiler error. For this reason `is_convertible` +can not be used to determine whether a type has a `public` copy-constructor or not.
+
+This template will also produce compiler errors if the conversion is ambiguous,
+for example:
+
+   struct A {};
+   struct B : A {};
+   struct C : A {};
+   struct D : B, C {};
+   // This produces a compiler error, the conversion is ambiguous:
+   bool const y = boost::is_convertible<D*,A*>::value;
+
+__std_ref 4 and 8.5.
+
+__compat This template is currently broken with Borland C++ Builder 5 (and earlier),
+for constructor-based conversions, and for the Metrowerks 7 (and earlier)
+compiler in all cases. If the compiler does not support `__is_abstract`, then the
+template parameter `To` must not be an abstract type.
+
+__header ` #include <boost/type_traits/is_convertible.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_convertible<int, double>` inherits from `__true_type`.]
+
+[:`is_convertible<const int, double>::type` is the type `__true_type`.]
+
+[:`is_convertible<int* const, int*>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_convertible<int const*, int*>::value` is an integral constant
+expression that evaluates to /false/: the conversion would require a `const_cast`.]
+
+[:`is_convertible<int const&, long>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_convertible<int, int>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_convertible<T, T>::value_type` is the type `bool`.]
+
+[endsect]
+
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_empty.qbk    Mon Feb  8 22:59:49 2010
@@ -0,0 +1,45 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_empty is_empty]
+   template <class T>
+   struct is_empty : public __tof {};
+
+__inherit If T is an empty class type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 10p5.
+
+__header ` #include <boost/type_traits/is_empty.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat In order to correctly detect empty classes this trait relies on either:
+
+* the compiler implementing zero sized empty base classes, or
+* the compiler providing __intrinsics to detect empty classes.
+
+Can not be used with incomplete types.
+
+Can not be used with union types, until is_union can be made to work.
+
+If the compiler does not support partial-specialization of class templates,
+then this template can not be used with abstract types.
+
+__examples
+
+[:Given: `struct empty_class {};` ]
+
+[:`is_empty<empty_class>` inherits from `__true_type`.]
+
+[:`is_empty<empty_class const>::type` is the type `__true_type`.]
+
+[:`is_empty<empty_class>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_empty<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_enum.qbk     Mon Feb  8 22:59:49 2010
@@ -0,0 +1,44 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_enum is_enum]
+   template <class T>
+   struct is_enum : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) enum type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 7.2.
+
+__header ` #include <boost/type_traits/is_enum.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__compat Requires a correctly functioning __is_convertible template;
+ this means that is_enum is currently broken under Borland C++ Builder 5,
+ and for the Metrowerks compiler prior to version 8, other compilers
+ should handle this template just fine.
+
+__examples
+
+[:Given: `enum my_enum { one, two };` ]
+
+[:`is_enum<my_enum>` inherits from `__true_type`.]
+
+[:`is_enum<my_enum const>::type` is the type `__true_type`.]
+
+[:`is_enum<my_enum>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_enum<my_enum&>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_enum<my_enum*>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_enum<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_floating_point.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,31 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_floating_point is_floating_point]
+   template <class T>
+   struct is_floating_point : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) floating point type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.1p8.
+
+__header ` #include <boost/type_traits/is_floating_point.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_floating_point<float>` inherits from `__true_type`.]
+
+[:`is_floating_point<double>::type` is the type `__true_type`.]
+
+[:`is_floating_point<long double>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_floating_point<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_function.qbk Mon Feb  8 22:59:49 2010
@@ -0,0 +1,74 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_function is_function]
+
+   template <class T>
+   struct is_function : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) function type then inherits from __true_type, +otherwise inherits from __false_type. Note that this template does not detect /pointers +to functions/, or /references to functions/, these are detected by __is_pointer and
+__is_reference respectively:
+
+   typedef int f1();      // f1 is of function type.
+   typedef int (f2*)();   // f2 is a pointer to a function.
+   typedef int (f3&)();   // f3 is a reference to a function.
+
+__std_ref 3.9.2p1 and 8.3.5.
+
+__header ` #include <boost/type_traits/is_function.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_function<int (void)>` inherits from `__true_type`.]
+
+[:`is_function<long (double, int)>::type` is the type `__true_type`.]
+
+[:`is_function<long (double, int)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_function<long (*)(double, int)>::value` is an integral constant
+expression that evaluates to /false/: the argument in this case is a pointer type,
+not a function type.]
+
+[:`is_function<long (&)(double, int)>::value` is an integral constant
+expression that evaluates to /false/: the argument in this case is a
+reference to a function, not a function type.]
+
+[:`is_function<long (MyClass::*)(double, int)>::value` is an integral constant +expression that evaluates to /false/: the argument in this case is a pointer
+to a member function.]
+
+[:`is_function<T>::value_type` is the type `bool`.]
+
+[tip Don't confuse function-types with pointers to functions:
+
+`typedef int f(double);`
+
+defines a function type,
+
+`f foo;`
+
+declares a prototype for a function of type `f`,
+
+`f* pf = foo;`
+
+`f& fr = foo;`
+
+declares a pointer and a reference to the function `foo`.
+
+If you want to detect whether some type is a pointer-to-function then use:
+
+`__is_function<__remove_pointer<T>::type>::value && __is_pointer<T>::value`
+
+or for pointers to member functions you can just use
+__is_member_function_pointer directly.
+]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_fundamental.qbk      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,32 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_fundamental is_fundamental]
+   template <class T>
+   struct is_fundamental : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) fundamental type then inherits from __true_type, +otherwise inherits from __false_type. Fundamental types include integral, floating +point and void types (see also __is_integral, __is_floating_point and __is_void)
+
+__std_ref 3.9.1.
+
+__header ` #include <boost/type_traits/is_fundamental.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_fundamental<int)>` inherits from `__true_type`.]
+
+[:`is_fundamental<double const>::type` is the type `__true_type`.]
+
+[:`is_fundamental<void>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_fundamental<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_integral.qbk Mon Feb  8 22:59:49 2010
@@ -0,0 +1,31 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_integral is_integral]
+   template <class T>
+   struct is_integral : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) integral type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.1p7.
+
+__header ` #include <boost/type_traits/is_integral.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_integral<int>` inherits from `__true_type`.]
+
+[:`is_integral<const char>::type` is the type `__true_type`.]
+
+[:`is_integral<long>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_integral<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_member_function_pointer.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,37 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_member_function_pointer is_member_function_pointer]
+   template <class T>
+   struct is_member_function_pointer : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) pointer to a member function
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 8.3.3.
+
+__header ` #include <boost/type_traits/is_member_function_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_member_function_pointer<int (MyClass::*)(void)>` inherits from `__true_type`.]
+
+[:`is_member_function_pointer<int (MyClass::*)(char)>::type` is the type `__true_type`.]
+
+[:`is_member_function_pointer<int (MyClass::*)(void)const>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_member_function_pointer<int (MyClass::*)>::value` is an integral constant +expression that evaluates to /false/: the argument in this case is a pointer to
+a data member and not a member function, see __is_member_object_pointer
+and __is_member_pointer]
+
+[:`is_member_function_pointer<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_member_object_pointer.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,37 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_member_object_pointer is_member_object_pointer]
+   template <class T>
+   struct is_member_object_pointer : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) pointer to a member object (a data member)
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 8.3.3.
+
+__header ` #include <boost/type_traits/is_member_object_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_member_object_pointer<int (MyClass::*)>` inherits from `__true_type`.]
+
+[:`is_member_object_pointer<double (MyClass::*)>::type` is the type `__true_type`.]
+
+[:`is_member_object_pointer<const int (MyClass::*)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_member_object_pointer<int (MyClass::*)(void)>::value` is an integral constant +expression that evaluates to /false/: the argument in this case is a pointer to
+a member function and not a member object, see __is_member_function_pointer
+and __is_member_pointer]
+
+[:`is_member_object_pointer<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_member_pointer.qbk Mon Feb 8 22:59:49 2010
@@ -0,0 +1,33 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_member_pointer is_member_pointer]
+   template <class T>
+   struct is_member_pointer : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) pointer to a member (either a function
+or a data member)
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+__std_ref 3.9.2 and 8.3.3.
+
+__header ` #include <boost/type_traits/is_member_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_member_pointer<int (MyClass::*)>` inherits from `__true_type`.]
+
+[:`is_member_pointer<int (MyClass::*)(char)>::type` is the type `__true_type`.]
+
+[:`is_member_pointer<int (MyClass::*)(void)const>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_member_pointer<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_object.qbk   Mon Feb  8 22:59:49 2010
@@ -0,0 +1,45 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_object is_object]
+   template <class T>
+   struct is_object : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) object type
+then inherits from __true_type,
+otherwise inherits from __false_type.  All types are object types except
+references, void, and function types.
+
+__std_ref 3.9p9.
+
+__header ` #include <boost/type_traits/is_object.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_object<int>` inherits from `__true_type`.]
+
+[:`is_object<int*>::type` is the type `__true_type`.]
+
+[:`is_object<int (*)(void)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_object<int (MyClass::*)(void)const>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_object<int &>::value` is an integral constant
+expression that evaluates to /false/: reference types are not objects]
+
+[:`is_object<int (double)>::value` is an integral constant
+expression that evaluates to /false/: function types are not objects]
+
+[:`is_object<const void>::value` is an integral constant
+expression that evaluates to /false/: void is not an object type]
+
+[:`is_object<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/is_pod.qbk      Mon Feb  8 22:59:49 2010
@@ -0,0 +1,51 @@
+[/
+  Copyright 2007 John Maddock.
+  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).
+]
+
+[section:is_pod is_pod]
+   template <class T>
+   struct is_pod : public __tof {};
+
+__inherit If T is a (possibly cv-qualified) POD type then inherits from __true_type,
+otherwise inherits from __false_type.
+
+POD stands for "Plain old data".
+Arithmetic types, and enumeration types,
+a pointers and pointer to members are all PODs. Classes and unions can also
+be POD's if they have no non-static data members that are of reference or
+non-POD type, no user defined constructors, no user defined assignment
+operators, no private or protected non-static data members,
+no virtual functions and no base classes.  Finally, a cv-qualified POD is
+still a POD, as is an array of PODs.
+
+__std_ref 3.9p10 and 9p4 (Note that POD's are also aggregates, see 8.5.1).
+
+__compat If the compiler does not support partial-specialization
+of class templates, then this template can not be used with function types.
+
+Without some (as yet unspecified) help from the compiler, is_pod will
+never report that a class or struct is a POD; this is always safe,
+if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the
+necessary compiler-__intrinsics.
+
+__header ` #include <boost/type_traits/is_pod.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`is_pod<int>` inherits from `__true_type`.]
+
+[:`is_pod<char*>::type` is the type `__true_type`.]
+
+[:`is_pod<int (*)(long)>::value` is an integral constant
+expression that evaluates to /true/.]
+
+[:`is_pod<MyClass>::value` is an integral constant
+expression that evaluates to /false/.]
+
+[:`is_pod<T>::value_type` is the type `bool`.]
+
+[endsect]
+
=======================================
***Additional files exist in this changeset.***

Other related posts:

  • » [boost-doc-zh] r381 committed - 升级至1.42.0,第七批,libs/目录t-z子目录 - boost-doc-zh