Boost logo

Boost-Commit :

From: john_at_[hidden]
Date: 2007-11-08 04:38:30


Author: johnmaddock
Date: 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
New Revision: 40925
URL: http://svn.boost.org/trac/boost/changeset/40925

Log:
Fixed license text.
Text files modified:
   trunk/libs/type_traits/doc/html/boost_typetraits/background.html | 205 +++++++++++++++++++--------------------
   trunk/libs/type_traits/doc/html/boost_typetraits/category.html | 15 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html | 32 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html | 29 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html | 77 +++++++--------
   trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html | 29 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html | 79 +++++++--------
   trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html | 77 ++++++--------
   trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html | 31 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/credits.html | 14 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/examples.html | 15 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html | 33 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html | 30 ++---
   trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html | 36 +++---
   trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html | 40 +++----
   trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html | 21 +--
   trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html | 61 +++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/intro.html | 18 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html | 30 ++--
   trunk/libs/type_traits/doc/html/boost_typetraits/reference.html | 15 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html | 61 ++++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html | 67 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html | 61 ++++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html | 59 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html | 30 ++--
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html | 46 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/decay.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/extent.html | 59 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html | 61 +++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html | 90 ++++++++--------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html | 19 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html | 37 +++---
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html | 44 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html | 41 +++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html | 18 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html | 53 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html | 58 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html | 55 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html | 18 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html | 19 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html | 40 +++---
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html | 20 +-
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html | 57 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html | 50 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html | 46 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html | 70 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html | 60 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html | 32 +++---
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html | 50 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html | 74 +++++++-------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html | 54 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html | 58 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html | 44 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html | 79 +++++++-------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html | 47 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html | 58 +++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html | 58 +++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html | 45 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html | 54 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html | 42 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html | 54 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html | 56 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html | 48 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html | 46 ++++----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html | 59 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html | 61 ++++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/promote.html | 60 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/rank.html | 52 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html | 65 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html | 61 ++++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html | 57 +++++-----
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html | 63 ++++++------
   trunk/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html | 28 ++--
   trunk/libs/type_traits/doc/html/boost_typetraits/user_defined.html | 27 ++--
   trunk/libs/type_traits/doc/html/index.html | 11 -
   trunk/libs/type_traits/doc/type_traits.qbk | 9
   91 files changed, 2188 insertions(+), 2257 deletions(-)

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/background.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/background.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/background.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Background and Tutorial</title>
+<title>Background and Tutorial</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="intro.html" title=" Introduction">
-<link rel="next" href="category.html" title=" Type Traits by Category">
+<link rel="prev" href="intro.html" title="Introduction">
+<link rel="next" href="category.html" title="Type Traits by Category">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.background"></a> Background and Tutorial</h2></div></div></div>
+<a name="boost_typetraits.background"></a> Background and Tutorial
+</h2></div></div></div>
 <p>
       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
@@ -45,29 +46,29 @@
       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 <tt class="computeroutput"><span class="identifier">strlen</span></tt> and <tt class="computeroutput"><span class="identifier">wcslen</span></tt>
+ more efficient methods available: for example, the C library functions <code class="computeroutput"><span class="identifier">strlen</span></code> and <code class="computeroutput"><span class="identifier">wcslen</span></code>
       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 <tt class="computeroutput"><span class="keyword">char</span></tt> and <tt class="computeroutput"><span class="keyword">wchar_t</span></tt>
- into the class <tt class="computeroutput"><span class="identifier">char_traits</span></tt>.
- Generic code that works with character strings can simply use <tt class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></tt> to determine the length of a null
- terminated string, safe in the knowledge that specializations of <tt class="computeroutput"><span class="identifier">char_traits</span></tt> will use the most appropriate
+ C++ standard library realized this, and abstracted the properties of <code class="computeroutput"><span class="keyword">char</span></code> and <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+ into the class <code class="computeroutput"><span class="identifier">char_traits</span></code>.
+ Generic code that works with character strings can simply use <code class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></code> to determine the length of a null
+ terminated string, safe in the knowledge that specializations of <code class="computeroutput"><span class="identifier">char_traits</span></code> will use the most appropriate
       method available to them.
     </p>
-<a name="boost_typetraits.background.type_traits"></a><h4>
-<a name="id385346"></a>
+<a name="boost_typetraits.background.type_traits"></a><h5>
+<a name="id437803"></a>
       <a href="background.html#boost_typetraits.background.type_traits">Type Traits</a>
- </h4>
+ </h5>
 <p>
- Class <tt class="computeroutput"><span class="identifier">char_traits</span></tt> is a classic
+ Class <code class="computeroutput"><span class="identifier">char_traits</span></code> is a classic
       example of a collection of type specific properties wrapped up in a single
       class - what Nathan Myers termed a <span class="emphasis"><em>baggage class</em></span>[1]. In the Boost type-traits library,
       we[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
+ 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.
@@ -76,51 +77,51 @@
       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 <tt class="computeroutput"><span class="identifier">type</span></tt>
+ a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
       that is the result of the transformation. All of the type-traits classes are
- defined inside namespace <tt class="computeroutput"><span class="identifier">boost</span></tt>;
+ defined inside namespace <code class="computeroutput"><span class="identifier">boost</span></code>;
       for brevity, namespace-qualification is omitted in most of the code samples
       given.
     </p>
-<a name="boost_typetraits.background.implementation"></a><h4>
-<a name="id385469"></a>
+<a name="boost_typetraits.background.implementation"></a><h5>
+<a name="id437920"></a>
       <a href="background.html#boost_typetraits.background.implementation">Implementation</a>
- </h4>
+ </h5>
 <p>
       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,
- <tt class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></tt> inherits
- from <tt class="computeroutput">true_type</tt>
- only if <tt class="computeroutput"><span class="identifier">T</span></tt> is <tt class="computeroutput"><span class="keyword">void</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> inherits
+ from <code class="computeroutput">true_type</code>
+ only if <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="keyword">void</span></code>.
     </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_void <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
+<span class="keyword">struct</span> is_void <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
-<span class="keyword">struct</span> is_void<span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
+<span class="keyword">struct</span> is_void<span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
 </pre>
 <p>
- Here we define a primary version of the template class <tt class="computeroutput">is_void</tt>,
- and provide a full-specialization when <tt class="computeroutput"><span class="identifier">T</span></tt>
- is <tt class="computeroutput"><span class="keyword">void</span></tt>. While full specialization
+ Here we define a primary version of the template class <code class="computeroutput">is_void</code>,
+ and provide a full-specialization when <code class="computeroutput"><span class="identifier">T</span></code>
+ is <code class="computeroutput"><span class="keyword">void</span></code>. 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 <tt class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></tt>:
+ template-class specialization. As an example, consider the class <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>:
       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:
     </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_pointer <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
+<span class="keyword">struct</span> is_pointer <span class="special">:</span> <span class="keyword">public</span> false_type<span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;</span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
+<span class="keyword">struct</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;</span> <span class="special">:</span> <span class="keyword">public</span> true_type<span class="special">{};</span>
 </pre>
 <p>
       The syntax for partial specialization is somewhat arcane and could easily occupy
@@ -152,35 +153,35 @@
       and close enough to the actual rule to be useful for everyday use.
     </p>
 <p>
- As a more complex example of partial specialization consider the class <tt class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></tt>. This
- class defines a single typedef-member <tt class="computeroutput"><span class="identifier">type</span></tt>
+ As a more complex example of partial specialization consider the class <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>. This
+ class defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
       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:
     </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_extent
+<span class="keyword">struct</span> remove_extent
 <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_extent<span class="special">&lt;</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]&gt;</span>
+<span class="keyword">struct</span> remove_extent<span class="special">&lt;</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]&gt;</span>
 <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
 </pre>
 <p>
- The aim of <tt class="computeroutput">remove_extent</tt>
+ The aim of <code class="computeroutput">remove_extent</code>
       is this: imagine a generic algorithm that is passed an array type as a template
- parameter, <tt class="computeroutput">remove_extent</tt>
+ parameter, <code class="computeroutput">remove_extent</code>
       provides a means of determining the underlying type of the array. For example
- <tt class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></tt> would evaluate to the type <tt class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></tt>. This example also shows that the number of
+ <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></code> would evaluate to the type <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>. 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.
     </p>
-<a name="boost_typetraits.background.optimized_copy"></a><h4>
-<a name="id456458"></a>
+<a name="boost_typetraits.background.optimized_copy"></a><h5>
+<a name="id490307"></a>
       <a href="background.html#boost_typetraits.background.optimized_copy">Optimized copy</a>
- </h4>
+ </h5>
 <p>
       As an example of how the type traits classes can be used, consider the standard
       library algorithm copy:
@@ -191,24 +192,24 @@
 </pre>
 <p>
       Obviously, there's no problem writing a generic version of copy that works
- for all iterator types <tt class="computeroutput"><span class="identifier">Iter1</span></tt>
- and <tt class="computeroutput"><span class="identifier">Iter2</span></tt>; however, there are
+ for all iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
+ and <code class="computeroutput"><span class="identifier">Iter2</span></code>; however, there are
       some circumstances when the copy operation can best be performed by a call
- to <tt class="computeroutput"><span class="identifier">memcpy</span></tt>. In order to implement
- copy in terms of <tt class="computeroutput"><span class="identifier">memcpy</span></tt> all
+ to <code class="computeroutput"><span class="identifier">memcpy</span></code>. In order to implement
+ copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code> all
       of the following conditions need to be met:
     </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
- Both of the iterator types <tt class="computeroutput"><span class="identifier">Iter1</span></tt>
- and <tt class="computeroutput"><span class="identifier">Iter2</span></tt> must be pointers.
+ Both of the iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
+ and <code class="computeroutput"><span class="identifier">Iter2</span></code> must be pointers.
       </li>
 <li>
- Both <tt class="computeroutput"><span class="identifier">Iter1</span></tt> and <tt class="computeroutput"><span class="identifier">Iter2</span></tt> must point to the same type - excluding
+ Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding
         const and volatile-qualifiers.
       </li>
 <li>
- The type pointed to by <tt class="computeroutput"><span class="identifier">Iter1</span></tt>
+ The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code>
         must have a trivial assignment operator.
       </li>
 </ul></div>
@@ -228,34 +229,33 @@
       </li>
 </ul></div>
 <p>
- If all these conditions are met then a type can be copied using <tt class="computeroutput"><span class="identifier">memcpy</span></tt> rather than using a compiler generated
- assignment operator. The type-traits library provides a class <tt class="computeroutput">has_trivial_assign</tt>,
- such that <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is true only if T has a trivial assignment
+ If all these conditions are met then a type can be copied using <code class="computeroutput"><span class="identifier">memcpy</span></code> rather than using a compiler generated
+ assignment operator. The type-traits library provides a class <code class="computeroutput">has_trivial_assign</code>,
+ such that <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> 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
+ 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.
     </p>
 <p>
- The code for an optimized version of copy that uses <tt class="computeroutput"><span class="identifier">memcpy</span></tt>
- where appropriate is given in <a href="examples/copy.html" title=" An Optimized Version
- of std::copy">the
- examples</a>. The code begins by defining a template function <tt class="computeroutput"><span class="identifier">do_copy</span></tt> that performs a "slow but safe"
- copy. The last parameter passed to this function may be either a <tt class="computeroutput">true_type</tt>
- or a <tt class="computeroutput">false_type</tt>.
+ The code for an optimized version of copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>
+ where appropriate is given in <a href="examples/copy.html" title="An Optimized Version of std::copy">the
+ examples</a>. The code begins by defining a template function <code class="computeroutput"><span class="identifier">do_copy</span></code> that performs a "slow but safe"
+ copy. The last parameter passed to this function may be either a <code class="computeroutput">true_type</code>
+ or a <code class="computeroutput">false_type</code>.
       Following that there is an overload of do<span class="underline">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 `</span>_true_type<tt class="computeroutput"><span class="special">.</span> <span class="identifier">Finally</span><span class="special">,</span> <span class="identifier">the</span> <span class="identifier">version</span>
- <span class="identifier">of</span> </tt>copy<tt class="computeroutput"> <span class="identifier">calls</span>
- </tt>do<span class="underline">copy`, passing `</span>_has_trivial_assign&lt;value_type&gt;()`
+ to the same type, and the final parameter must be a `</span>_true_type<code class="computeroutput"><span class="special">.</span> <span class="identifier">Finally</span><span class="special">,</span> <span class="identifier">the</span> <span class="identifier">version</span>
+ <span class="identifier">of</span> </code>copy<code class="computeroutput"> <span class="identifier">calls</span>
+ </code>do<span class="underline">copy`, passing `</span>_has_trivial_assign&lt;value_type&gt;()`
       as the final parameter: this will dispatch to the optimized version where appropriate,
       otherwise it will call the "slow but safe version".
     </p>
-<a name="boost_typetraits.background.was_it_worth_it_"></a><h4>
-<a name="id456995"></a>
+<a name="boost_typetraits.background.was_it_worth_it_"></a><h5>
+<a name="id490852"></a>
       <a href="background.html#boost_typetraits.background.was_it_worth_it_">Was it worth it?</a>
- </h4>
+ </h5>
 <p>
       It has often been repeated in these columns that "premature optimization
       is the root of all evil" [4].
@@ -286,9 +286,9 @@
       </li>
 </ul></div>
 <div class="table">
-<a name="id457059"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy&lt;const
+<a name="id490923"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy&lt;const
     T*, T*&gt;` (times in micro-seconds)</b></p>
-<table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const
+<div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const
     T*, T*&gt;` (times in micro-seconds)">
 <colgroup>
 <col>
@@ -382,12 +382,12 @@
           </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
-<a name="boost_typetraits.background.pair_of_references"></a><h4>
-<a name="id457209"></a>
+<br class="table-break"><a name="boost_typetraits.background.pair_of_references"></a><h5>
+<a name="id491080"></a>
       <a href="background.html#boost_typetraits.background.pair_of_references">Pair of References</a>
- </h4>
+ </h5>
 <p>
       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
@@ -397,7 +397,7 @@
       references [6].
     </p>
 <p>
- First, let us examine the definition of <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></tt>, omitting
+ First, let us examine the definition of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>, omitting
       the comparison operators, default constructor, and template copy constructor
       for simplicity:
     </p>
@@ -423,8 +423,8 @@
       to hold non-reference types, references, and constant references:
     </p>
 <div class="table">
-<a name="id457580"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
-<table class="table" summary="Required Constructor Argument Types">
+<a name="id491443"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
+<div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
 <colgroup>
 <col>
 <col>
@@ -432,7 +432,7 @@
 <thead><tr>
 <th>
           <p>
- Type of <tt class="computeroutput"><span class="identifier">T1</span></tt>
+ Type of <code class="computeroutput"><span class="identifier">T1</span></code>
           </p>
           </th>
 <th>
@@ -479,18 +479,18 @@
           </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
-<p>
+<br class="table-break"><p>
       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
+ 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.
     </p>
 <div class="table">
-<a name="id457708"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor
+<a name="id491567"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor
     type</b></p>
-<table class="table" summary="Using add_reference to synthesize the correct constructor
+<div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor
     type">
 <colgroup>
 <col>
@@ -500,17 +500,17 @@
 <thead><tr>
 <th>
           <p>
- Type of <tt class="computeroutput"><span class="identifier">T1</span></tt>
+ Type of <code class="computeroutput"><span class="identifier">T1</span></code>
           </p>
           </th>
 <th>
           <p>
- Type of <tt class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></tt>
+ Type of <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></code>
           </p>
           </th>
 <th>
           <p>
- Type of <tt class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ Type of <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
           </p>
           </th>
 </tr></thead>
@@ -567,10 +567,10 @@
           </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
-<p>
- This allows us to build a primary template definition for <tt class="computeroutput"><span class="identifier">pair</span></tt>
+<br class="table-break"><p>
+ This allows us to build a primary template definition for <code class="computeroutput"><span class="identifier">pair</span></code>
       that can contain non-reference types, reference types, and constant reference
       types:
     </p>
@@ -584,20 +584,20 @@
 <span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span>
 <span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span>
 
-<span class="identifier">pair</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nfirst</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T2</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nsecond</span><span class="special">)</span>
+<span class="identifier">pair</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nfirst</span><span class="special">,</span>
+ <span class="identifier">boost</span><span class="special">::</span>add_reference<span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T2</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nsecond</span><span class="special">)</span>
 <span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
 <span class="special">};</span>
 </pre>
 <p>
       Add back in the standard comparison operators, default constructor, and template
- copy constructor (which are all the same), and you have a <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></tt> that
+ copy constructor (which are all the same), and you have a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> that
       can hold reference types!
     </p>
 <p>
       This same extension could have been done using partial template specialization
- of <tt class="computeroutput"><span class="identifier">pair</span></tt>, but to specialize
- <tt class="computeroutput"><span class="identifier">pair</span></tt> in this way would require
+ of <code class="computeroutput"><span class="identifier">pair</span></code>, but to specialize
+ <code class="computeroutput"><span class="identifier">pair</span></code> 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
@@ -605,10 +605,10 @@
       partial specialization to the type traits classes, resulting in code that is
       easier to maintain and easier to understand.
     </p>
-<a name="boost_typetraits.background.conclusion"></a><h4>
-<a name="id458327"></a>
+<a name="boost_typetraits.background.conclusion"></a><h5>
+<a name="id492190"></a>
       <a href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
- </h4>
+ </h5>
 <p>
       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
@@ -618,18 +618,18 @@
       does not have to sink to the lowest common denominator, and that templates
       can be optimal as well as generic.
     </p>
-<a name="boost_typetraits.background.acknowledgements"></a><h4>
-<a name="id458374"></a>
+<a name="boost_typetraits.background.acknowledgements"></a><h5>
+<a name="id492491"></a>
       <a href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
- </h4>
+ </h5>
 <p>
       The authors would like to thank Beman Dawes and Howard Hinnant for their helpful
       comments when preparing this article.
     </p>
-<a name="background.references"></a><a name="boost_typetraits.background.references"></a><h4>
-<a name="id458410"></a>
+<a name="background.references"></a><a name="boost_typetraits.background.references"></a><h5>
+<a name="id492525"></a>
       <a href="background.html#boost_typetraits.background.references">References</a>
- </h4>
+ </h5>
 <div class="orderedlist"><ol type="1">
 <li>
         Nathan C. Myers, C++ Report, June 1995.
@@ -682,8 +682,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Type Traits by Category</title>
+<title>Type Traits by Category</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="background.html" title=" Background and Tutorial">
-<link rel="next" href="category/value_traits.html" title=" Type Traits
- that Describe the Properties of a Type">
+<link rel="prev" href="background.html" title="Background and Tutorial">
+<link rel="next" href="category/value_traits.html" title="Type Traits that Describe the Properties of a Type">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.category"></a> Type Traits by Category</h2></div></div></div>
+<a name="boost_typetraits.category"></a> Type Traits by Category
+</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="category/value_traits.html"> Type Traits
       that Describe the Properties of a Type</a></span></dt>
@@ -52,8 +52,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,16 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Synthesizing Types
- with Specific Alignments</title>
+<title>Synthesizing Types with Specific Alignments</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../category.html" title=" Type Traits by Category">
-<link rel="prev" href="transform.html" title=" Type Traits that
- Transform One Type to Another">
-<link rel="next" href="function.html" title=" Decomposing Function
- Types">
+<link rel="up" href="../category.html" title="Type Traits by Category">
+<link rel="prev" href="transform.html" title="Type Traits that Transform One Type to Another">
+<link rel="next" href="function.html" title="Decomposing Function Types">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -27,24 +24,24 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.category.alignment"></a><a href="alignment.html" title=" Synthesizing Types
- with Specific Alignments"> Synthesizing Types
- with Specific Alignments</a></h3></div></div></div>
+<a name="boost_typetraits.category.alignment"></a><a href="alignment.html" title="Synthesizing Types with Specific Alignments"> Synthesizing Types
+ with Specific Alignments</a>
+</h3></div></div></div>
 <p>
         Some low level memory management routines need to synthesize a POD type with
- specific alignment properties. The template <tt class="computeroutput">type_with_alignment</tt>
- finds the smallest type with a specified alignment, while template <tt class="computeroutput">aligned_storage</tt>
+ specific alignment properties. The template <code class="computeroutput">type_with_alignment</code>
+ finds the smallest type with a specified alignment, while template <code class="computeroutput">aligned_storage</code>
         creates a type with a specific size and alignment.
       </p>
 <p>
- <span class="bold"><b>Synopsis</b></span>
+ <span class="bold"><strong>Synopsis</strong></span>
       </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> type_with_alignment<span class="special">;</span>
+<span class="keyword">struct</span> type_with_alignment<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> aligned_storage<span class="special">;</span>
+<span class="keyword">struct</span> aligned_storage<span class="special">;</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -54,8 +51,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Decomposing Function
- Types</title>
+<title>Decomposing Function Types</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../category.html" title=" Type Traits by Category">
-<link rel="prev" href="alignment.html" title=" Synthesizing Types
- with Specific Alignments">
-<link rel="next" href="../user_defined.html" title=" User Defined Specializations">
+<link rel="up" href="../category.html" title="Type Traits by Category">
+<link rel="prev" href="alignment.html" title="Synthesizing Types with Specific Alignments">
+<link rel="next" href="../user_defined.html" title="User Defined Specializations">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,21 +24,21 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.category.function"></a><a href="function.html" title=" Decomposing Function
- Types"> Decomposing Function
- Types</a></h3></div></div></div>
+<a name="boost_typetraits.category.function"></a><a href="function.html" title="Decomposing Function Types"> Decomposing Function
+ Types</a>
+</h3></div></div></div>
 <p>
- The class template function_traits
- extracts information from function types (see also is_function).
+ 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.
       </p>
 <p>
- <span class="bold"><b>Synopsis</b></span>
+ <span class="bold"><strong>Synopsis</strong></span>
       </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> function_traits<span class="special">;</span>
+<span class="keyword">struct</span> function_traits<span class="special">;</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -50,8 +48,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,16 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Type Traits that
- Transform One Type to Another</title>
+<title>Type Traits that Transform One Type to Another</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../category.html" title=" Type Traits by Category">
-<link rel="prev" href="value_traits/relate.html" title=" Relationships
- Between Two Types">
-<link rel="next" href="alignment.html" title=" Synthesizing Types
- with Specific Alignments">
+<link rel="up" href="../category.html" title="Type Traits by Category">
+<link rel="prev" href="value_traits/relate.html" title="Relationships Between Two Types">
+<link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -27,79 +24,78 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.category.transform"></a><a href="transform.html" title=" Type Traits that
- Transform One Type to Another"> Type Traits that
- Transform One Type to Another</a></h3></div></div></div>
+<a name="boost_typetraits.category.transform"></a><a href="transform.html" title="Type Traits that Transform One Type to Another"> Type Traits that
+ Transform One Type to Another</a>
+</h3></div></div></div>
 <p>
         The following templates transform one type to another, based upon some well-defined
- rule. Each template has a single member called <tt class="computeroutput"><span class="identifier">type</span></tt>
+ rule. Each template has a single member called <code class="computeroutput"><span class="identifier">type</span></code>
         that is the result of applying the transformation to the template argument
- <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>Synopsis:</b></span>
+ <span class="bold"><strong>Synopsis:</strong></span>
       </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> add_const<span class="special">;</span>
+<span class="keyword">struct</span> add_const<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> add_cv<span class="special">;</span>
+<span class="keyword">struct</span> add_cv<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> add_pointer<span class="special">;</span>
+<span class="keyword">struct</span> add_pointer<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> add_reference<span class="special">;</span>
+<span class="keyword">struct</span> add_reference<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> add_volatile<span class="special">;</span>
+<span class="keyword">struct</span> add_volatile<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> decay<span class="special">;</span>
+<span class="keyword">struct</span> decay<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../reference/floating_point_promotion.html" title="
- floating_point_promotion">floating_point_promotion</a><span class="special">;</span>
+<span class="keyword">struct</span> floating_point_promotion<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> integral_promotion<span class="special">;</span>
+<span class="keyword">struct</span> integral_promotion<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> make_signed<span class="special">;</span>
+<span class="keyword">struct</span> make_signed<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> make_unsigned<span class="special">;</span>
+<span class="keyword">struct</span> make_unsigned<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> promote<span class="special">;</span>
+<span class="keyword">struct</span> promote<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_all_extents<span class="special">;</span>
+<span class="keyword">struct</span> remove_all_extents<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_const<span class="special">;</span>
+<span class="keyword">struct</span> remove_const<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_cv<span class="special">;</span>
+<span class="keyword">struct</span> remove_cv<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_extent<span class="special">;</span>
+<span class="keyword">struct</span> remove_extent<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_pointer<span class="special">;</span>
+<span class="keyword">struct</span> remove_pointer<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_reference<span class="special">;</span>
+<span class="keyword">struct</span> remove_reference<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> remove_volatile<span class="special">;</span>
+<span class="keyword">struct</span> remove_volatile<span class="special">;</span>
 </pre>
-<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h4>
-<a name="id462389"></a>
+<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5>
+<a name="id496340"></a>
         <a href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
         Compiler Workarounds:</a>
- </h4>
+ </h5>
 <p>
         For all of these templates support for partial specialization of class templates
         is required to correctly implement the transformation. On the other hand,
@@ -133,8 +129,8 @@
 </pre>
 <p>
         and the second part provides the library's users with a mechanism to make
- the above code work not only for <tt class="computeroutput"><span class="keyword">char</span></tt>,
- <tt class="computeroutput"><span class="keyword">int</span></tt> or other built-in type,
+ the above code work not only for <code class="computeroutput"><span class="keyword">char</span></code>,
+ <code class="computeroutput"><span class="keyword">int</span></code> or other built-in type,
         but for their own types as well:
       </p>
 <pre class="programlisting">
@@ -150,7 +146,7 @@
 </span></pre>
 <p>
         Note that the macro BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION evaluates
- to nothing on those compilers that <span class="bold"><b>do</b></span> support
+ to nothing on those compilers that <span class="bold"><strong>do</strong></span> support
         partial specialization.
       </p>
 </div>
@@ -161,8 +157,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Type Traits
- that Describe the Properties of a Type</title>
+<title>Type Traits that Describe the Properties of a Type</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../category.html" title=" Type Traits by Category">
-<link rel="prev" href="../category.html" title=" Type Traits by Category">
-<link rel="next" href="value_traits/primary.html" title=" Categorizing
- a Type">
+<link rel="up" href="../category.html" title="Type Traits by Category">
+<link rel="prev" href="../category.html" title="Type Traits by Category">
+<link rel="next" href="value_traits/primary.html" title="Categorizing a Type">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,9 +24,9 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.category.value_traits"></a><a href="value_traits.html" title=" Type Traits
- that Describe the Properties of a Type"> Type Traits
- that Describe the Properties of a Type</a></h3></div></div></div>
+<a name="boost_typetraits.category.value_traits"></a><a href="value_traits.html" title="Type Traits that Describe the Properties of a Type"> Type Traits
+ that Describe the Properties of a Type</a>
+</h3></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="value_traits/primary.html"> Categorizing
         a Type</a></span></dt>
@@ -39,13 +37,13 @@
 </dl></div>
 <p>
         These traits are all <span class="emphasis"><em>value traits</em></span>, which is to say the
- traits classes all inherit from integral_constant,
+ traits classes all inherit from integral_constant,
         and are used to access some numerical property of a type. Often this is a
         simple true or false Boolean value, but in a few cases may be some other
         integer value (for example when dealing with type alignments, or array bounds:
- see <tt class="computeroutput">alignment_of</tt>,
- <tt class="computeroutput">rank</tt>
- and <tt class="computeroutput">extent</tt>).
+ see <code class="computeroutput">alignment_of</code>,
+ <code class="computeroutput">rank</code>
+ and <code class="computeroutput">extent</code>).
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -55,8 +53,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,17 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Categorizing
- a Type</title>
+<title>Categorizing a Type</title>
 <link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../value_traits.html" title=" Type Traits
- that Describe the Properties of a Type">
-<link rel="prev" href="../value_traits.html" title=" Type Traits
- that Describe the Properties of a Type">
-<link rel="next" href="properties.html" title="
- General Type Properties">
+<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
+<link rel="prev" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
+<link rel="next" href="properties.html" title="General Type Properties">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -28,71 +24,69 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="boost_typetraits.category.value_traits.primary"></a><a href="primary.html" title=" Categorizing
- a Type"> Categorizing
- a Type</a></h4></div></div></div>
+<a name="boost_typetraits.category.value_traits.primary"></a><a href="primary.html" title="Categorizing a Type"> Categorizing
+ a Type</a>
+</h4></div></div></div>
 <p>
- These traits identify what "kind" of type some type <tt class="computeroutput"><span class="identifier">T</span></tt> is. These are split into two groups:
+ These traits identify what "kind" of type some type <code class="computeroutput"><span class="identifier">T</span></code> is. These are split into two groups:
           primary traits which are all mutually exclusive, and composite traits that
           are compositions of one or more primary traits.
         </p>
 <p>
- For any given type, exactly one primary type trait will inherit from true_type,
- and all the others will inherit from false_type,
+ For any given type, exactly one primary type trait will inherit from true_type,
+ and all the others will inherit from false_type,
           in other words these traits are mutually exclusive.
         </p>
 <p>
- This means that <tt class="computeroutput">is_integral<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
- and <tt class="computeroutput">is_floating_point<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ This means that <code class="computeroutput">is_integral<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
+ and <code class="computeroutput">is_floating_point<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
           will only ever be true for built-in types; if you want to check for a user-defined
           class type that behaves "as if" it is an integral or floating
- point type, then use the <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span>
- <span class="keyword">template</span></tt> instead.
+ point type, then use the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span>
+ <span class="keyword">template</span></code> instead.
         </p>
 <p>
- <span class="bold"><b>Synopsis:</b></span>
+ <span class="bold"><strong>Synopsis:</strong></span>
         </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_array<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_array<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_class<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_class<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_complex<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_complex<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_enum<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_enum<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_floating_point<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_floating_point<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_function<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_function<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_integral<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_integral<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/is_member_function_pointer.html" title="
- is_member_function_pointer">is_member_function_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_member_function_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/is_member_object_pointer.html" title="
- is_member_object_pointer">is_member_object_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_member_object_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_reference<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_reference<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_union<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_union<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
   
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_void<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
+<span class="keyword">struct</span> is_void<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
 </pre>
 <p>
           The following traits are made up of the union of one or more type categorizations.
@@ -101,22 +95,22 @@
         </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_arithmetic<span class="special">;</span>
+<span class="keyword">struct</span> is_arithmetic<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_compound<span class="special">;</span>
+<span class="keyword">struct</span> is_compound<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_fundamental<span class="special">;</span>
+<span class="keyword">struct</span> is_fundamental<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_member_pointer<span class="special">;</span>
+<span class="keyword">struct</span> is_member_pointer<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_object<span class="special">;</span>
+<span class="keyword">struct</span> is_object<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_scalar<span class="special">;</span>
+<span class="keyword">struct</span> is_scalar<span class="special">;</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -126,8 +120,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,17 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- General Type Properties</title>
+<title>General Type Properties</title>
 <link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../value_traits.html" title=" Type Traits
- that Describe the Properties of a Type">
-<link rel="prev" href="primary.html" title=" Categorizing
- a Type">
-<link rel="next" href="relate.html" title=" Relationships
- Between Two Types">
+<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
+<link rel="prev" href="primary.html" title="Categorizing a Type">
+<link rel="next" href="relate.html" title="Relationships Between Two Types">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -28,91 +24,87 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="boost_typetraits.category.value_traits.properties"></a><a href="properties.html" title="
- General Type Properties">
- General Type Properties</a></h4></div></div></div>
+<a name="boost_typetraits.category.value_traits.properties"></a><a href="properties.html" title="General Type Properties">
+ General Type Properties</a>
+</h4></div></div></div>
 <p>
           The following templates describe the general properties of a type.
         </p>
 <p>
- <span class="bold"><b>Synopsis:</b></span>
+ <span class="bold"><strong>Synopsis:</strong></span>
         </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> alignment_of<span class="special">;</span>
+<span class="keyword">struct</span> alignment_of<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_nothrow_assign<span class="special">;</span>
+<span class="keyword">struct</span> has_nothrow_assign<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/has_nothrow_constructor.html" title="
- has_nothrow_constructor">has_nothrow_constructor</a><span class="special">;</span>
+<span class="keyword">struct</span> has_nothrow_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/has_nothrow_constructor.html" title="
- has_nothrow_constructor">has_nothrow_default_constructor</a><span class="special">;</span>
+<span class="keyword">struct</span> has_nothrow_default_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_nothrow_copy<span class="special">;</span>
+<span class="keyword">struct</span> has_nothrow_copy<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_nothrow_copy_constructor<span class="special">;</span>
+<span class="keyword">struct</span> has_nothrow_copy_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_trivial_assign<span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_assign<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/has_trivial_constructor.html" title="
- has_trivial_constructor">has_trivial_constructor</a><span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <a href="../../reference/has_trivial_constructor.html" title="
- has_trivial_constructor">has_trivial_default_constructor</a><span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_default_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_trivial_copy<span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_copy<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_trivial_copy_constructor<span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_copy_constructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_trivial_destructor<span class="special">;</span>
+<span class="keyword">struct</span> has_trivial_destructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> has_virtual_destructor<span class="special">;</span>
+<span class="keyword">struct</span> has_virtual_destructor<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_abstract<span class="special">;</span>
+<span class="keyword">struct</span> is_abstract<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_const<span class="special">;</span>
+<span class="keyword">struct</span> is_const<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_empty<span class="special">;</span>
+<span class="keyword">struct</span> is_empty<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_stateless<span class="special">;</span>
+<span class="keyword">struct</span> is_stateless<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_pod<span class="special">;</span>
+<span class="keyword">struct</span> is_pod<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_polymorphic<span class="special">;</span>
+<span class="keyword">struct</span> is_polymorphic<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_signed<span class="special">;</span>
+<span class="keyword">struct</span> is_signed<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_unsigned<span class="special">;</span>
+<span class="keyword">struct</span> is_unsigned<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_volatile<span class="special">;</span>
+<span class="keyword">struct</span> is_volatile<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> extent<span class="special">;</span>
+<span class="keyword">struct</span> extent<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> rank<span class="special">;</span>
+<span class="keyword">struct</span> rank<span class="special">;</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -122,8 +114,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,17 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Relationships
- Between Two Types</title>
+<title>Relationships Between Two Types</title>
 <link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../value_traits.html" title=" Type Traits
- that Describe the Properties of a Type">
-<link rel="prev" href="properties.html" title="
- General Type Properties">
-<link rel="next" href="../transform.html" title=" Type Traits that
- Transform One Type to Another">
+<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
+<link rel="prev" href="properties.html" title="General Type Properties">
+<link rel="next" href="../transform.html" title="Type Traits that Transform One Type to Another">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -28,25 +24,25 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="boost_typetraits.category.value_traits.relate"></a><a href="relate.html" title=" Relationships
- Between Two Types"> Relationships
- Between Two Types</a></h4></div></div></div>
+<a name="boost_typetraits.category.value_traits.relate"></a><a href="relate.html" title="Relationships Between Two Types"> Relationships
+ Between Two Types</a>
+</h4></div></div></div>
 <p>
           These templates determine the whether there is a relationship between two
           types:
         </p>
 <p>
- <span class="bold"><b>Synopsis:</b></span>
+ <span class="bold"><strong>Synopsis:</strong></span>
         </p>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_base_of<span class="special">;</span>
+<span class="keyword">struct</span> is_base_of<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_convertible<span class="special">;</span>
+<span class="keyword">struct</span> is_convertible<span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> is_same<span class="special">;</span>
+<span class="keyword">struct</span> is_same<span class="special">;</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -56,8 +52,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/credits.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/credits.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/credits.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,12 +1,12 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Credits</title>
+<title>Credits</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="reference/type_with_alignment.html" title=" type_with_alignment">
+<link rel="prev" href="reference/type_with_alignment.html" title="type_with_alignment">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -23,7 +23,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.credits"></a> Credits</h2></div></div></div>
+<a name="boost_typetraits.credits"></a> Credits
+</h2></div></div></div>
 <p>
       This documentation was pulled together by John Maddock, using Boost.Quickbook
       and Boost.DocBook.
@@ -48,7 +49,7 @@
       Aleksey Gurtovoy added MPL integration to the library.
     </p>
 <p>
- The is_convertible
+ The is_convertible
       template is based on code originally devised by Andrei Alexandrescu, see "<a href="http://www.cuj.com/experts/1810/alexandr.htm?topic=experts" target="_top">Generic&lt;Programming&gt;:
       Mappings between Types and Values</a>".
     </p>
@@ -65,8 +66,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Examples</title>
+<title>Examples</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="mpl.html" title=" MPL Interoperability">
-<link rel="next" href="examples/copy.html" title=" An Optimized Version
- of std::copy">
+<link rel="prev" href="mpl.html" title="MPL Interoperability">
+<link rel="next" href="examples/copy.html" title="An Optimized Version of std::copy">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.examples"></a> Examples</h2></div></div></div>
+<a name="boost_typetraits.examples"></a> Examples
+</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="examples/copy.html"> An Optimized Version
       of std::copy</a></span></dt>
@@ -46,8 +46,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> An Optimized Version
- of std::copy</title>
+<title>An Optimized Version of std::copy</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../examples.html" title=" Examples">
-<link rel="prev" href="../examples.html" title=" Examples">
-<link rel="next" href="fill.html" title=" An Optimised Version
- of std::fill">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="../examples.html" title="Examples">
+<link rel="next" href="fill.html" title="An Optimised Version of std::fill">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,13 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.examples.copy"></a><a href="copy.html" title=" An Optimized Version
- of std::copy"> An Optimized Version
- of std::copy</a></h3></div></div></div>
+<a name="boost_typetraits.examples.copy"></a><a href="copy.html" title="An Optimized Version of std::copy"> An Optimized Version
+ of std::copy</a>
+</h3></div></div></div>
 <p>
- Demonstrates a version of <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></tt>
- that uses <tt class="computeroutput">has_trivial_assign</tt>
- to determine whether to use <tt class="computeroutput"><span class="identifier">memcpy</span></tt>
+ Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code>
+ that uses <code class="computeroutput">has_trivial_assign</code>
+ to determine whether to use <code class="computeroutput"><span class="identifier">memcpy</span></code>
         to optimise the copy operation (see copy_example.cpp):
       </p>
 <pre class="programlisting">
@@ -45,7 +43,7 @@
 <span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>
 
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">&gt;</span>
-<span class="identifier">I2</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">&gt;&amp;)</span>
+<span class="identifier">I2</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">&gt;&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span>
    <span class="special">{</span>
@@ -57,7 +55,7 @@
 <span class="special">}</span>
 
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="identifier">T</span><span class="special">*</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
+<span class="identifier">T</span><span class="special">*</span> <span class="identifier">copy_imp</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="identifier">memcpy</span><span class="special">(</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">)*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">));</span>
    <span class="keyword">return</span> <span class="identifier">out</span><span class="special">+(</span><span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">);</span>
@@ -75,7 +73,7 @@
 </span> <span class="comment">// requirement we detect with overload resolution):
 </span> <span class="comment">//
 </span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
- <span class="keyword">return</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span>has_trivial_assign<span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;());</span>
+ <span class="keyword">return</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span>has_trivial_assign<span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;());</span>
 <span class="special">}</span>
 </pre>
 </div>
@@ -86,8 +84,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,16 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> An Example that
- Omits Destructor Calls For Types with Trivial Destructors</title>
+<title>An Example that Omits Destructor Calls For Types with Trivial Destructors</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../examples.html" title=" Examples">
-<link rel="prev" href="fill.html" title=" An Optimised Version
- of std::fill">
-<link rel="next" href="iter.html" title=" An improved Version
- of std::iter_swap">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="fill.html" title="An Optimised Version of std::fill">
+<link rel="next" href="iter.html" title="An improved Version of std::iter_swap">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -27,11 +24,11 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.examples.destruct"></a><a href="destruct.html" title=" An Example that
- Omits Destructor Calls For Types with Trivial Destructors"> An Example that
- Omits Destructor Calls For Types with Trivial Destructors</a></h3></div></div></div>
+<a name="boost_typetraits.examples.destruct"></a><a href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors"> An Example that
+ Omits Destructor Calls For Types with Trivial Destructors</a>
+</h3></div></div></div>
 <p>
- Demonstrates a simple algorithm that uses <tt class="computeroutput"><span class="identifier">__has_trivial_destruct</span></tt>
+ Demonstrates a simple algorithm that uses <code class="computeroutput"><span class="identifier">__has_trivial_destruct</span></code>
         to determine whether to destructors need to be called (see trivial_destructor_example.cpp):
       </p>
 <pre class="programlisting">
@@ -44,7 +41,7 @@
 <span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>false_type<span class="special">&amp;)</span>
+<span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>false_type<span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span>
    <span class="special">{</span>
@@ -54,7 +51,7 @@
 <span class="special">}</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
+<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
 <span class="special">{</span>
 <span class="special">}</span>
 
@@ -63,7 +60,7 @@
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p1</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">p2</span><span class="special">)</span>
 <span class="special">{</span>
- <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">p1</span><span class="special">,</span> <span class="identifier">p2</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>has_trivial_destructor<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;());</span>
+ <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">p1</span><span class="special">,</span> <span class="identifier">p2</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>has_trivial_destructor<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;());</span>
 <span class="special">}</span>
 </pre>
 </div>
@@ -74,8 +71,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,16 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> An Optimised Version
- of std::fill</title>
+<title>An Optimised Version of std::fill</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../examples.html" title=" Examples">
-<link rel="prev" href="copy.html" title=" An Optimized Version
- of std::copy">
-<link rel="next" href="destruct.html" title=" An Example that
- Omits Destructor Calls For Types with Trivial Destructors">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="copy.html" title="An Optimized Version of std::copy">
+<link rel="next" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -27,13 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.examples.fill"></a><a href="fill.html" title=" An Optimised Version
- of std::fill"> An Optimised Version
- of std::fill</a></h3></div></div></div>
+<a name="boost_typetraits.examples.fill"></a><a href="fill.html" title="An Optimised Version of std::fill"> An Optimised Version
+ of std::fill</a>
+</h3></div></div></div>
 <p>
- Demonstrates a version of <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></tt>
- that uses <tt class="computeroutput">has_trivial_assign</tt>
- to determine whether to use <tt class="computeroutput"><span class="identifier">memset</span></tt>
+ Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></code>
+ that uses <code class="computeroutput">has_trivial_assign</code>
+ to determine whether to use <code class="computeroutput"><span class="identifier">memset</span></code>
         to optimise the fill operation (see fill_example.cpp):
       </p>
 <pre class="programlisting">
@@ -44,7 +41,7 @@
 </span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">&gt;&amp;)</span>
+<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">&gt;&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span>
    <span class="special">{</span>
@@ -54,7 +51,7 @@
 <span class="special">}</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
+<span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">memset</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">val</span><span class="special">,</span> <span class="identifier">last</span><span class="special">-</span><span class="identifier">first</span><span class="special">);</span>
 <span class="special">}</span>
@@ -68,8 +65,8 @@
 </span> <span class="comment">// We can do an optimised fill if T has a trivial assignment
 </span> <span class="comment">// operator and if it's size is one:
 </span> <span class="comment">//
-</span> <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
- <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>has_trivial_assign<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">)&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span>
+</span> <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
+ <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>has_trivial_assign<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">)&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span>
    <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">val</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span>
 <span class="special">}</span>
 </pre>
@@ -81,8 +78,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,16 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> An improved Version
- of std::iter_swap</title>
+<title>An improved Version of std::iter_swap</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../examples.html" title=" Examples">
-<link rel="prev" href="destruct.html" title=" An Example that
- Omits Destructor Calls For Types with Trivial Destructors">
-<link rel="next" href="to_double.html" title=" Convert Numeric
- Types and Enums to double">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors">
+<link rel="next" href="to_double.html" title="Convert Numeric Types and Enums to double">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -27,14 +24,14 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.examples.iter"></a><a href="iter.html" title=" An improved Version
- of std::iter_swap"> An improved Version
- of std::iter_swap</a></h3></div></div></div>
+<a name="boost_typetraits.examples.iter"></a><a href="iter.html" title="An improved Version of std::iter_swap"> An improved Version
+ of std::iter_swap</a>
+</h3></div></div></div>
 <p>
- Demonstrates a version of <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></tt>
+ Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code>
         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 <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></tt>
- of it's dereferenced arguments (the same as <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></tt>
+ iterators or not, if they're not then it just does a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>
+ of it's dereferenced arguments (the same as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code>
         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 iter_swap_example.cpp):
@@ -48,7 +45,7 @@
 </span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
-<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>false_type<span class="special">&amp;)</span>
+<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>false_type<span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">v_t</span><span class="special">;</span>
    <span class="identifier">v_t</span> <span class="identifier">v</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">one</span><span class="special">;</span>
@@ -56,7 +53,7 @@
    <span class="special">*</span><span class="identifier">two</span> <span class="special">=</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="special">}</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
-<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
+<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span>true_type<span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span><span class="special">;</span>
    <span class="identifier">swap</span><span class="special">(*</span><span class="identifier">one</span><span class="special">,</span> <span class="special">*</span><span class="identifier">two</span><span class="special">);</span>
@@ -74,10 +71,10 @@
 </span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">r1_t</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I2</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">r2_t</span><span class="special">;</span>
 
- <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
- <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_reference<span class="special">&lt;</span><span class="identifier">r1_t</span><span class="special">&gt;::</span><span class="identifier">value</span>
- <span class="special">&amp;&amp;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_reference<span class="special">&lt;</span><span class="identifier">r2_t</span><span class="special">&gt;::</span><span class="identifier">value</span>
- <span class="special">&amp;&amp;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_same<span class="special">&lt;</span><span class="identifier">r1_t</span><span class="special">,</span> <span class="identifier">r2_t</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span>integral_constant<span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
+ <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_reference<span class="special">&lt;</span><span class="identifier">r1_t</span><span class="special">&gt;::</span><span class="identifier">value</span>
+ <span class="special">&amp;&amp;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_reference<span class="special">&lt;</span><span class="identifier">r2_t</span><span class="special">&gt;::</span><span class="identifier">value</span>
+ <span class="special">&amp;&amp;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span>is_same<span class="special">&lt;</span><span class="identifier">r1_t</span><span class="special">,</span> <span class="identifier">r2_t</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span>
 
    <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span>
 <span class="special">}</span>
@@ -90,8 +87,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Convert Numeric
- Types and Enums to double</title>
+<title>Convert Numeric Types and Enums to double</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../examples.html" title=" Examples">
-<link rel="prev" href="iter.html" title=" An improved Version
- of std::iter_swap">
-<link rel="next" href="../reference.html" title=" Alphabetical Reference">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="iter.html" title="An improved Version of std::iter_swap">
+<link rel="next" href="../reference.html" title="Alphabetical Reference">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,9 +24,9 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.examples.to_double"></a><a href="to_double.html" title=" Convert Numeric
- Types and Enums to double"> Convert Numeric
- Types and Enums to double</a></h3></div></div></div>
+<a name="boost_typetraits.examples.to_double"></a><a href="to_double.html" title="Convert Numeric Types and Enums to double"> Convert Numeric
+ Types and Enums to double</a>
+</h3></div></div></div>
 <p>
         Demonstrates a conversion of <a href="../../../../libs/numeric/conversion/doc/definitions.html#numtypes" target="_top">Numeric
         Types</a> and enum types to double:
@@ -49,8 +47,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Support for Compiler Intrinsics</title>
+<title>Support for Compiler Intrinsics</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="user_defined.html" title=" User Defined Specializations">
-<link rel="next" href="mpl.html" title=" MPL Interoperability">
+<link rel="prev" href="user_defined.html" title="User Defined Specializations">
+<link rel="next" href="mpl.html" title="MPL Interoperability">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.intrinsics"></a> Support for Compiler Intrinsics</h2></div></div></div>
+<a name="boost_typetraits.intrinsics"></a> Support for Compiler Intrinsics
+</h2></div></div></div>
 <p>
       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
@@ -37,18 +38,16 @@
       for all types (but all have safe fallback positions if this support is unavailable):
     </p>
 <div class="itemizedlist"><ul type="disc">
-<li>is_union</li>
-<li>is_pod</li>
-<li><a href="reference/has_trivial_constructor.html" title="
- has_trivial_constructor">has_trivial_constructor</a></li>
-<li>has_trivial_copy</li>
-<li>has_trivial_assign</li>
-<li>has_trivial_destructor</li>
-<li><a href="reference/has_nothrow_constructor.html" title="
- has_nothrow_constructor">has_nothrow_constructor</a></li>
-<li>has_nothrow_copy</li>
-<li>has_nothrow_assign</li>
-<li>has_virtual_destructor</li>
+<li>is_union</li>
+<li>is_pod</li>
+<li>has_trivial_constructor</li>
+<li>has_trivial_copy</li>
+<li>has_trivial_assign</li>
+<li>has_trivial_destructor</li>
+<li>has_nothrow_constructor</li>
+<li>has_nothrow_copy</li>
+<li>has_nothrow_assign</li>
+<li>has_virtual_destructor</li>
 </ul></div>
 <p>
       The following traits classes can't be portably implemented in the C++ language,
@@ -56,15 +55,15 @@
       all the compilers we know about:
     </p>
 <div class="itemizedlist"><ul type="disc">
-<li>is_empty</li>
-<li>is_polymorphic</li>
+<li>is_empty</li>
+<li>is_polymorphic</li>
 </ul></div>
 <p>
       The following traits classes are dependent on one or more of the above:
     </p>
 <div class="itemizedlist"><ul type="disc">
-<li>is_class</li>
-<li>is_stateless</li>
+<li>is_class</li>
+<li>is_stateless</li>
 </ul></div>
 <p>
       The hooks for compiler-intrinsic support are defined in boost/type_traits/intrinsics.hpp,
@@ -72,8 +71,8 @@
       of the following macros:
     </p>
 <div class="table">
-<a name="id464633"></a><p class="title"><b>Table 1.4. Macros for Compiler Intrinsics</b></p>
-<table class="table" summary="Macros for Compiler Intrinsics">
+<a name="id498584"></a><p class="title"><b>Table 1.4. Macros for Compiler Intrinsics</b></p>
+<div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics">
 <colgroup>
 <col>
 <col>
@@ -175,8 +174,8 @@
           </td>
 <td>
           <p>
- Should evaluate to true if <tt class="computeroutput"><span class="identifier">T</span>
- <span class="identifier">x</span><span class="special">;</span></tt>
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span>
+ <span class="identifier">x</span><span class="special">;</span></code>
             can not throw
           </p>
           </td>
@@ -189,7 +188,7 @@
           </td>
 <td>
           <p>
- Should evaluate to true if <tt class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></tt> can not throw
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code> can not throw
           </p>
           </td>
 </tr>
@@ -201,11 +200,11 @@
           </td>
 <td>
           <p>
- Should evaluate to true if <tt class="computeroutput"><span class="identifier">T</span>
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span>
             <span class="identifier">t</span><span class="special">,</span>
             <span class="identifier">u</span><span class="special">;</span>
             <span class="identifier">t</span> <span class="special">=</span>
- <span class="identifier">u</span></tt> can not throw
+ <span class="identifier">u</span></code> can not throw
           </p>
           </td>
 </tr>
@@ -222,8 +221,9 @@
           </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -232,8 +232,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/intro.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/intro.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/intro.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Introduction</title>
+<title>Introduction</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="prev" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="next" href="background.html" title=" Background and Tutorial">
+<link rel="next" href="background.html" title="Background and Tutorial">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.intro"></a> Introduction</h2></div></div></div>
+<a name="boost_typetraits.intro"></a> Introduction
+</h2></div></div></div>
 <p>
       The Boost type-traits library contains a set of very specific traits classes,
       each of which encapsulate a single trait from the C++ type system; for example,
@@ -33,15 +34,15 @@
     </p>
 <p>
       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
+ the type true_type
+ if the type has the specified property and inherits from false_type
       otherwise.
     </p>
 <p>
       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 <tt class="computeroutput"><span class="identifier">type</span></tt>
+ a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
       that is the result of the transformation.
     </p>
 </div>
@@ -52,8 +53,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> MPL Interoperability</title>
+<title>MPL Interoperability</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="intrinsics.html" title=" Support for Compiler Intrinsics">
-<link rel="next" href="examples.html" title=" Examples">
+<link rel="prev" href="intrinsics.html" title="Support for Compiler Intrinsics">
+<link rel="next" href="examples.html" title="Examples">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.mpl"></a> MPL Interoperability</h2></div></div></div>
+<a name="boost_typetraits.mpl"></a> MPL Interoperability
+</h2></div></div></div>
 <p>
       All the value based traits in this library conform to MPL's requirements for
       an <a href="../../../libs/mpl/doc/refmanual/integral-constant.html" target="_top">Integral
@@ -32,14 +33,14 @@
       for broken compilers.
     </p>
 <p>
- Purely as an implementation detail, this means that <tt class="computeroutput">true_type</tt>
- inherits from boost::mpl::true_,
- <tt class="computeroutput">false_type</tt>
- inherits from boost::mpl::false_,
- and <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
- <span class="identifier">v</span><span class="special">&gt;</span></tt>
- inherits from boost::mpl::integral_c<T,v>
- (provided <tt class="computeroutput"><span class="identifier">T</span></tt> is not <tt class="computeroutput"><span class="keyword">bool</span></tt>)
+ Purely as an implementation detail, this means that <code class="computeroutput">true_type</code>
+ inherits from boost::mpl::true_,
+ <code class="computeroutput">false_type</code>
+ inherits from boost::mpl::false_,
+ and <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
+ <span class="identifier">v</span><span class="special">&gt;</span></code>
+ inherits from boost::mpl::integral_c<T,v>
+ (provided <code class="computeroutput"><span class="identifier">T</span></code> is not <code class="computeroutput"><span class="keyword">bool</span></code>)
     </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -49,8 +50,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Alphabetical Reference</title>
+<title>Alphabetical Reference</title>
 <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="prev" href="examples/to_double.html" title=" Convert Numeric
- Types and Enums to double">
-<link rel="next" href="reference/add_const.html" title=" add_const">
+<link rel="prev" href="examples/to_double.html" title="Convert Numeric Types and Enums to double">
+<link rel="next" href="reference/add_const.html" title="add_const">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_typetraits.reference"></a> Alphabetical Reference</h2></div></div></div>
+<a name="boost_typetraits.reference"></a> Alphabetical Reference
+</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"> add_const</span></dt>
 <dt><span class="section"> add_cv</span></dt>
@@ -109,8 +109,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> add_const</title>
+<title>add_const</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="../reference.html" title=" Alphabetical Reference">
-<link rel="next" href="add_cv.html" title=" add_cv">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="../reference.html" title="Alphabetical Reference">
+<link rel="next" href="add_cv.html" title="add_cv">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,38 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.add_const"></a> add_const</h3></div></div></div>
+<a name="boost_typetraits.reference.add_const"></a> add_const
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_const</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> The same type as <tt class="computeroutput"><span class="identifier">T</span>
- <span class="keyword">const</span></tt> for all <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span>
+ <span class="keyword">const</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial specialization of class-templates then this template
- will compile, but the member <tt class="computeroutput"><span class="identifier">type</span></tt>
- will always be the same as type <tt class="computeroutput"><span class="identifier">T</span></tt>
+ will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code>
+ will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>
         except where <a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
         workarounds</a> have been applied.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id469779"></a><p class="title"><b>Table 1.5. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id503727"></a><p class="title"><b>Table 1.5. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -75,55 +76,56 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
- <span class="keyword">const</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
+ <span class="keyword">const</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -132,8 +134,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> add_cv</title>
+<title>add_cv</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="add_const.html" title=" add_const">
-<link rel="next" href="add_pointer.html" title=" add_pointer">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="add_const.html" title="add_const">
+<link rel="next" href="add_pointer.html" title="add_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,38 +24,39 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.add_cv"></a> add_cv</h3></div></div></div>
+<a name="boost_typetraits.reference.add_cv"></a> add_cv
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_cv</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> The same type as <tt class="computeroutput"><span class="identifier">T</span>
- <span class="keyword">const</span> <span class="keyword">volatile</span></tt>
- for all <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span>
+ <span class="keyword">const</span> <span class="keyword">volatile</span></code>
+ for all <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial specialization of class-templates then this template
- will compile, but the member <tt class="computeroutput"><span class="identifier">type</span></tt>
- will always be the same as type <tt class="computeroutput"><span class="identifier">T</span></tt>
+ will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code>
+ will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>
         except where <a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
         workarounds</a> have been applied.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id470419"></a><p class="title"><b>Table 1.6. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id504366"></a><p class="title"><b>Table 1.6. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -76,57 +77,58 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
- <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
+ <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
- <span class="keyword">const</span> <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
+ <span class="keyword">const</span> <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
- <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
+ <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -135,8 +137,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> add_pointer</title>
+<title>add_pointer</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="add_cv.html" title=" add_cv">
-<link rel="next" href="add_reference.html" title=" add_reference">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="add_cv.html" title="add_cv">
+<link rel="next" href="add_reference.html" title="add_reference">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,40 +24,41 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.add_pointer"></a> add_pointer</h3></div></div></div>
+<a name="boost_typetraits.reference.add_pointer"></a> add_pointer
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_pointer</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> The same type as <tt class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span></tt>.
+ <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span></code>.
       </p>
 <p>
- The rationale for this template is that it produces the same type as <tt class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&amp;</span><span class="identifier">t</span><span class="special">)</span></tt>, where
- <tt class="computeroutput"><span class="identifier">t</span></tt> is an object of type <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ The rationale for this template is that it produces the same type as <code class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&amp;</span><span class="identifier">t</span><span class="special">)</span></code>, where
+ <code class="computeroutput"><span class="identifier">t</span></code> is an object of type <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 8.3.1.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.1.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial specialization of class-templates then this template
- will compile, but the member <tt class="computeroutput"><span class="identifier">type</span></tt>
- will always be the same as type <tt class="computeroutput"><span class="identifier">T</span></tt>
+ will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code>
+ will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>
         except where <a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
         workarounds</a> have been applied.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id471134"></a><p class="title"><b>Table 1.7. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id505080"></a><p class="title"><b>Table 1.7. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -78,54 +79,55 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">**</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">**</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -134,8 +136,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> add_reference</title>
+<title>add_reference</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="add_pointer.html" title=" add_pointer">
-<link rel="next" href="add_volatile.html" title=" add_volatile">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="add_pointer.html" title="add_pointer">
+<link rel="next" href="add_volatile.html" title="add_volatile">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,38 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.add_reference"></a> add_reference</h3></div></div></div>
+<a name="boost_typetraits.reference.add_reference"></a> add_reference
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_reference</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> If <tt class="computeroutput"><span class="identifier">T</span></tt>
- is not a reference type then <tt class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></tt>, otherwise <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code>
+ is not a reference type then <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>, otherwise <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 8.3.2.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.2.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial specialization of class-templates then this template
- will compile, but the member <tt class="computeroutput"><span class="identifier">type</span></tt>
- will always be the same as type <tt class="computeroutput"><span class="identifier">T</span></tt>
+ will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code>
+ will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>
         except where <a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
         workarounds</a> have been applied.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id471775"></a><p class="title"><b>Table 1.8. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id505719"></a><p class="title"><b>Table 1.8. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -75,54 +76,55 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -131,8 +133,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> add_volatile</title>
+<title>add_volatile</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="add_reference.html" title=" add_reference">
-<link rel="next" href="aligned_storage.html" title=" aligned_storage">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="add_reference.html" title="add_reference">
+<link rel="next" href="aligned_storage.html" title="aligned_storage">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,38 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.add_volatile"></a> add_volatile</h3></div></div></div>
+<a name="boost_typetraits.reference.add_volatile"></a> add_volatile
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_volatile</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> The same type as <tt class="computeroutput"><span class="identifier">T</span>
- <span class="keyword">volatile</span></tt> for all <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span>
+ <span class="keyword">volatile</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial specialization of class-templates then this template
- will compile, but the member <tt class="computeroutput"><span class="identifier">type</span></tt>
- will always be the same as type <tt class="computeroutput"><span class="identifier">T</span></tt>
+ will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code>
+ will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code>
         except where <a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
         workarounds</a> have been applied.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id472405"></a><p class="title"><b>Table 1.9. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id506349"></a><p class="title"><b>Table 1.9. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -75,56 +76,57 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
- <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
+ <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">add_volatile</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
- <span class="keyword">volatile</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
+ <span class="keyword">volatile</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -133,8 +135,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> aligned_storage</title>
+<title>aligned_storage</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="add_volatile.html" title=" add_volatile">
-<link rel="next" href="alignment_of.html" title=" alignment_of">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="add_volatile.html" title="add_volatile">
+<link rel="next" href="alignment_of.html" title="alignment_of">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,23 +24,24 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.aligned_storage"></a> aligned_storage</h3></div></div></div>
+<a name="boost_typetraits.reference.aligned_storage"></a> aligned_storage
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">aligned_storage</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> a built-in or POD type with size
- <tt class="computeroutput"><span class="identifier">Size</span></tt> and an alignment that
- is a multiple of <tt class="computeroutput"><span class="identifier">Align</span></tt>.
+ <span class="bold"><strong>type:</strong></span> a built-in or POD type with size
+ <code class="computeroutput"><span class="identifier">Size</span></code> and an alignment that
+ is a multiple of <code class="computeroutput"><span class="identifier">Align</span></code>.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">aligned_storage</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">aligned_storage</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -50,8 +51,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> alignment_of</title>
+<title>alignment_of</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="aligned_storage.html" title=" aligned_storage">
-<link rel="next" href="decay.html" title=" decay">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="aligned_storage.html" title="aligned_storage">
+<link rel="next" href="decay.html" title="decay">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,35 +24,36 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.alignment_of"></a> alignment_of</h3></div></div></div>
+<a name="boost_typetraits.reference.alignment_of"></a> alignment_of
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">alignment_of</span> <span class="special">:</span> <span class="keyword">public</span> integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">alignment_of</span> <span class="special">:</span> <span class="keyword">public</span> integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> Class template alignment<span class="underline">of inherits from `</span>_integral_constant&lt;std::size_t,
- ALIGNOF(T)&gt;<tt class="computeroutput"><span class="special">,</span> <span class="identifier">where</span>
- </tt>ALIGNOF(T)` is the alignment of type T.
+ <span class="bold"><strong>Inherits:</strong></span> Class template alignment<span class="underline">of inherits from `</span>_integral_constant&lt;std::size_t,
+ ALIGNOF(T)&gt;<code class="computeroutput"><span class="special">,</span> <span class="identifier">where</span>
+ </code>ALIGNOF(T)` is the alignment of type T.
       </p>
 <p>
- <span class="emphasis"><em>Note: strictly speaking you should only rely on the value of <tt class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></tt> being
+ <span class="emphasis"><em>Note: strictly speaking you should only rely on the value of <code class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code> 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.</em></span>
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;</span></tt>.
+ <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;</span></code>.
           </p>
 <p>
         </p>
@@ -61,7 +62,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">char</span><span class="special">)&gt;</span></tt>.
+ <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">char</span><span class="special">)&gt;</span></code>.
           </p>
 <p>
         </p>
@@ -70,8 +71,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
- with value <tt class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></tt>.
+ <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
+ with value <code class="computeroutput"><span class="identifier">ALIGNOF</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></code>.
           </p>
 <p>
         </p>
@@ -80,7 +81,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></tt>.
+ <code class="computeroutput"><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>.
           </p>
 <p>
         </p>
@@ -93,8 +94,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/decay.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/decay.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/decay.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> decay</title>
+<title>decay</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="alignment_of.html" title=" alignment_of">
-<link rel="next" href="extent.html" title=" extent">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="alignment_of.html" title="alignment_of">
+<link rel="next" href="extent.html" title="extent">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,32 +24,33 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.decay"></a> decay</h3></div></div></div>
+<a name="boost_typetraits.reference.decay"></a> decay
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">decay</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> Let <tt class="computeroutput"><span class="identifier">U</span></tt>
- be the result of <tt class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>, then if <tt class="computeroutput"><span class="identifier">U</span></tt>
- is an array type, the result is <tt class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;*</span></tt>,
- otherwise if <tt class="computeroutput"><span class="identifier">U</span></tt> is a function
- type then the result is <tt class="computeroutput"><span class="identifier">U</span><span class="special">*</span></tt>, otherwise the result is <tt class="computeroutput"><span class="identifier">U</span></tt>.
+ <span class="bold"><strong>type:</strong></span> Let <code class="computeroutput"><span class="identifier">U</span></code>
+ be the result of <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>, then if <code class="computeroutput"><span class="identifier">U</span></code>
+ is an array type, the result is <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;*</span></code>,
+ otherwise if <code class="computeroutput"><span class="identifier">U</span></code> is a function
+ type then the result is <code class="computeroutput"><span class="identifier">U</span><span class="special">*</span></code>, otherwise the result is <code class="computeroutput"><span class="identifier">U</span></code>.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.1.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">decay</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">decay</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id474069"></a><p class="title"><b>Table 1.10. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id508010"></a><p class="title"><b>Table 1.10. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -70,66 +71,67 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]*</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]*</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)[</span><span class="number">2</span><span class="special">]&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)[</span><span class="number">2</span><span class="special">]&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">*</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)(</span><span class="keyword">double</span><span class="special">)&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">decay</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)(</span><span class="keyword">double</span><span class="special">)&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">double</span><span class="special">)</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -138,8 +140,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/extent.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/extent.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/extent.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> extent</title>
+<title>extent</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="decay.html" title=" decay">
-<link rel="next" href="floating_point_promotion.html" title="
- floating_point_promotion">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="decay.html" title="decay">
+<link rel="next" href="floating_point_promotion.html" title="floating_point_promotion">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,36 +24,37 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.extent"></a> extent</h3></div></div></div>
+<a name="boost_typetraits.reference.extent"></a> extent
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">extent</span> <span class="special">:</span> <span class="keyword">public</span> integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)&gt;</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">extent</span> <span class="special">:</span> <span class="keyword">public</span> integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)&gt;</span> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> Class template extent inherits
- from <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)&gt;</span></tt>,
- where <tt class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></tt> is the number of elements in the N'th array
- dimention of type <tt class="computeroutput"><span class="identifier">T</span></tt>.
+ <span class="bold"><strong>Inherits:</strong></span> Class template extent inherits
+ from <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)&gt;</span></code>,
+ where <code class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></code> is the number of elements in the N'th array
+ dimention of type <code class="computeroutput"><span class="identifier">T</span></code>.
       </p>
 <p>
- If <tt class="computeroutput"><span class="identifier">T</span></tt> is not an array type,
- or if <tt class="computeroutput"><span class="identifier">N</span> <span class="special">&gt;</span>
- rank<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>, or if the N'th array bound is incomplete,
- then <tt class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></tt> is zero.
+ If <code class="computeroutput"><span class="identifier">T</span></code> is not an array type,
+ or if <code class="computeroutput"><span class="identifier">N</span> <span class="special">&gt;</span>
+ rank<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>, or if the N'th array bound is incomplete,
+ then <code class="computeroutput"><span class="identifier">EXTENT</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">)</span></code> is zero.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">extent</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">extent</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">1</span><span class="special">]&gt;</span></tt> inherits from <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;</span></tt>.
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">1</span><span class="special">]&gt;</span></code> inherits from <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;</span></code>.
           </p>
 <p>
         </p>
@@ -63,8 +63,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">],</span>
- <span class="number">1</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">3</span><span class="special">&gt;</span></tt>.
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">][</span><span class="number">4</span><span class="special">],</span>
+ <span class="number">1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">integral_constant<span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="number">3</span><span class="special">&gt;</span></code>.
           </p>
 <p>
         </p>
@@ -73,7 +73,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">]&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">]&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>4</em></span>.
           </p>
 <p>
@@ -83,7 +83,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">]&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>0</em></span>.
           </p>
 <p>
@@ -93,7 +93,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">],</span> <span class="number">1</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[][</span><span class="number">2</span><span class="special">],</span> <span class="number">1</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>2</em></span>.
           </p>
 <p>
@@ -103,7 +103,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>0</em></span>.
           </p>
 <p>
@@ -113,7 +113,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></tt>.
+ <code class="computeroutput"><span class="identifier">extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>.
           </p>
 <p>
         </p>
@@ -126,8 +126,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- floating_point_promotion</title>
+<title>floating_point_promotion</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="extent.html" title=" extent">
-<link rel="next" href="function_traits.html" title=" function_traits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="extent.html" title="extent">
+<link rel="next" href="function_traits.html" title="function_traits">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,34 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.floating_point_promotion"></a><a href="floating_point_promotion.html" title="
- floating_point_promotion">
- floating_point_promotion</a></h3></div></div></div>
+<a name="boost_typetraits.reference.floating_point_promotion"></a><a href="floating_point_promotion.html" title="floating_point_promotion">
+ floating_point_promotion</a>
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">floating_point_promotion</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> If floating point promotion can be
- applied to an rvalue of type <tt class="computeroutput"><span class="identifier">T</span></tt>,
- then applies floating point promotion to <tt class="computeroutput"><span class="identifier">T</span></tt>
- and keeps cv-qualifiers of <tt class="computeroutput"><span class="identifier">T</span></tt>,
- otherwise leaves <tt class="computeroutput"><span class="identifier">T</span></tt> unchanged.
+ <span class="bold"><strong>type:</strong></span> If floating point promotion can be
+ applied to an rvalue of type <code class="computeroutput"><span class="identifier">T</span></code>,
+ then applies floating point promotion to <code class="computeroutput"><span class="identifier">T</span></code>
+ and keeps cv-qualifiers of <code class="computeroutput"><span class="identifier">T</span></code>,
+ otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 4.6.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 4.6.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">floating_point_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">floating_point_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id475860"></a><p class="title"><b>Table 1.11. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id509798"></a><p class="title"><b>Table 1.11. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -73,43 +72,44 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">float</span>
- <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">float</span>
+ <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">double</span> <span class="keyword">const</span></tt>
+ <code class="computeroutput"><span class="keyword">double</span> <span class="keyword">const</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">float</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">float</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">floating_point_promotion</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">short</span></tt>
+ <code class="computeroutput"><span class="keyword">short</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -118,8 +118,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> function_traits</title>
+<title>function_traits</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="floating_point_promotion.html" title="
- floating_point_promotion">
-<link rel="next" href="has_nothrow_assign.html" title=" has_nothrow_assign">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="floating_point_promotion.html" title="floating_point_promotion">
+<link rel="next" href="has_nothrow_assign.html" title="has_nothrow_assign">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,14 +24,15 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.function_traits"></a> function_traits</h3></div></div></div>
+<a name="boost_typetraits.reference.function_traits"></a> function_traits
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">function_traits</span>
 <span class="special">{</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">arity</span> <span class="special">=</span> <i class="replaceable"><tt>see-below</tt></i><span class="special">;</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">result_type</span><span class="special">;</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> arg<i class="replaceable"><tt>N</tt></i>_type<span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">arity</span> <span class="special">=</span> <em class="replaceable"><code>see-below</code></em><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">result_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> arg<em class="replaceable"><code>N</code></em>_type<span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
@@ -43,8 +43,8 @@
           The compiler supports partial specialization of class templates.
         </li>
 <li>
- The template argument <tt class="computeroutput"><span class="identifier">T</span></tt>
- is a <span class="emphasis"><em>function type</em></span>, note that this <span class="emphasis"><em><span class="bold"><b>is not</b></span></em></span> the same thing as a <span class="emphasis"><em>pointer
+ The template argument <code class="computeroutput"><span class="identifier">T</span></code>
+ is a <span class="emphasis"><em>function type</em></span>, note that this <span class="emphasis"><em><span class="bold"><strong>is not</strong></span></em></span> the same thing as a <span class="emphasis"><em>pointer
           to a function</em></span>.
         </li>
 </ul></div>
@@ -53,15 +53,15 @@
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/html/images/tip.png"></td>
 <th align="left">Tip</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
+<tr><td align="left" valign="top"><p>
           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.
+ functions. To convert a function pointer type to a suitable type use remove_pointer.
         </p></td></tr>
 </table></div>
 <div class="table">
-<a name="id476342"></a><p class="title"><b>Table 1.12. Function Traits Members</b></p>
-<table class="table" summary="Function Traits Members">
+<a name="id510280"></a><p class="title"><b>Table 1.12. Function Traits Members</b></p>
+<div class="table-contents"><table class="table" summary="Function Traits Members">
 <colgroup>
 <col>
 <col>
@@ -82,49 +82,49 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">arity</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">arity</span></code>
             </p>
             </td>
 <td>
             <p>
               An integral constant expression that gives the number of arguments
- accepted by the function type <tt class="computeroutput"><span class="identifier">F</span></tt>.
+ accepted by the function type <code class="computeroutput"><span class="identifier">F</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">result_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">result_type</span></code>
             </p>
             </td>
 <td>
             <p>
- The type returned by function type <tt class="computeroutput"><span class="identifier">F</span></tt>.
+ The type returned by function type <code class="computeroutput"><span class="identifier">F</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span>arg<i class="replaceable"><tt>N</tt></i>_type</tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span>arg<em class="replaceable"><code>N</code></em>_type</code>
             </p>
             </td>
 <td>
             <p>
- The <i class="replaceable"><tt>N</tt></i>th argument type of function type <tt class="computeroutput"><span class="identifier">F</span></tt>,
- where <tt class="computeroutput"><span class="number">1</span> <span class="special">&lt;=</span>
+ The <em class="replaceable"><code>N</code></em>th argument type of function type <code class="computeroutput"><span class="identifier">F</span></code>,
+ where <code class="computeroutput"><span class="number">1</span> <span class="special">&lt;=</span>
               <span class="identifier">N</span> <span class="special">&lt;=</span>
- <span class="identifier">arity</span></tt> of <tt class="computeroutput"><span class="identifier">F</span></tt>.
+ <span class="identifier">arity</span></code> of <code class="computeroutput"><span class="identifier">F</span></code>.
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
-<div class="table">
-<a name="id476620"></a><p class="title"><b>Table 1.13. Examples</b></p>
-<table class="table" summary="Examples">
+<br class="table-break"><div class="table">
+<a name="id510557"></a><p class="title"><b>Table 1.13. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -145,7 +145,7 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">arity</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">arity</span></code>
             </p>
             </td>
 <td>
@@ -157,7 +157,7 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">arity</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">arity</span></code>
             </p>
             </td>
 <td>
@@ -169,7 +169,7 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arity</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arity</span></code>
             </p>
             </td>
 <td>
@@ -181,60 +181,60 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">result_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">result_type</span></code>
             </p>
             </td>
 <td>
             <p>
- The type <tt class="computeroutput"><span class="keyword">void</span></tt>.
+ The type <code class="computeroutput"><span class="keyword">void</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">result_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">result_type</span></code>
             </p>
             </td>
 <td>
             <p>
- The type <tt class="computeroutput"><span class="keyword">long</span></tt>.
+ The type <code class="computeroutput"><span class="keyword">long</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">arg1_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">arg1_type</span></code>
             </p>
             </td>
 <td>
             <p>
- The type <tt class="computeroutput"><span class="keyword">int</span></tt>.
+ The type <code class="computeroutput"><span class="keyword">int</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arg4_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arg4_type</span></code>
             </p>
             </td>
 <td>
             <p>
- The type <tt class="computeroutput"><span class="keyword">void</span><span class="special">*</span></tt>.
+ The type <code class="computeroutput"><span class="keyword">void</span><span class="special">*</span></code>.
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arg5_type</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*)&gt;::</span><span class="identifier">arg5_type</span></code>
             </p>
             </td>
 <td>
             <p>
- A compiler error: there is no <tt class="computeroutput"><span class="identifier">arg4_type</span></tt>
+ A compiler error: there is no <code class="computeroutput"><span class="identifier">arg4_type</span></code>
               since there are only three arguments.
             </p>
             </td>
@@ -242,7 +242,7 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">arity</span></tt>
+ <code class="computeroutput"><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">arity</span></code>
             </p>
             </td>
 <td>
@@ -253,8 +253,9 @@
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -263,8 +264,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_nothrow_default_constructor</title>
+<title>has_nothrow_default_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_nothrow_cp_cons.html" title=" has_nothrow_copy_constructor">
-<link rel="next" href="has_trivial_assign.html" title=" has_trivial_assign">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor">
+<link rel="next" href="has_trivial_assign.html" title="has_trivial_assign">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,10 +24,10 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_no_throw_def_cons"></a> has_nothrow_default_constructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_no_throw_def_cons"></a> has_nothrow_default_constructor
+</h3></div></div></div>
 <p>
- See <a href="has_nothrow_constructor.html" title="
- has_nothrow_constructor">has_nothrow_constructor</a>.
+ See has_nothrow_constructor.
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -37,8 +37,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_nothrow_assign</title>
+<title>has_nothrow_assign</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="function_traits.html" title=" function_traits">
-<link rel="next" href="has_nothrow_constructor.html" title="
- has_nothrow_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="function_traits.html" title="function_traits">
+<link rel="next" href="has_nothrow_constructor.html" title="has_nothrow_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,34 +24,35 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_nothrow_assign"></a> has_nothrow_assign</h3></div></div></div>
+<a name="boost_typetraits.reference.has_nothrow_assign"></a> has_nothrow_assign
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_nothrow_assign</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_nothrow_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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 <tt class="computeroutput"><span class="identifier">T</span></tt> must be a complete
+ <span class="bold"><strong>Inherits:</strong></span> 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 <code class="computeroutput"><span class="identifier">T</span></code> must be a complete
         type.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
 <p>
- Without some (as yet unspecified) help from the compiler, <tt class="computeroutput"><span class="identifier">has_nothrow_assign</span></tt>
+ Without some (as yet unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_assign</span></code>
         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".
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -62,8 +62,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- has_nothrow_constructor</title>
+<title>has_nothrow_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_nothrow_assign.html" title=" has_nothrow_assign">
-<link rel="next" href="has_nothrow_copy.html" title=" has_nothrow_copy">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_nothrow_assign.html" title="has_nothrow_assign">
+<link rel="next" href="has_nothrow_copy.html" title="has_nothrow_copy">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,42 +24,42 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_nothrow_constructor"></a><a href="has_nothrow_constructor.html" title="
- has_nothrow_constructor">
- has_nothrow_constructor</a></h3></div></div></div>
+<a name="boost_typetraits.reference.has_nothrow_constructor"></a><a href="has_nothrow_constructor.html" title="has_nothrow_constructor">
+ has_nothrow_constructor</a>
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_nothrow_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_nothrow_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_nothrow_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_nothrow_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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 <tt class="computeroutput"><span class="identifier">T</span></tt> must be a complete
+ <span class="bold"><strong>Inherits:</strong></span> 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 <code class="computeroutput"><span class="identifier">T</span></code> must be a complete
         type.
       </p>
 <p>
         These two traits are synonyms for each other.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
 <p>
- Without some (as yet unspecified) help from the compiler, <tt class="computeroutput"><span class="identifier">has_nothrow_constructor</span></tt>
+ Without some (as yet unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_constructor</span></code>
         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
+ C++ 8 has the necessary compiler intrinsics
         to ensure that this trait "just works".
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -70,8 +69,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_nothrow_copy</title>
+<title>has_nothrow_copy</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_nothrow_constructor.html" title="
- has_nothrow_constructor">
-<link rel="next" href="has_nothrow_cp_cons.html" title=" has_nothrow_copy_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_nothrow_constructor.html" title="has_nothrow_constructor">
+<link rel="next" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,40 +24,41 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_nothrow_copy"></a> has_nothrow_copy</h3></div></div></div>
+<a name="boost_typetraits.reference.has_nothrow_copy"></a> has_nothrow_copy
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_nothrow_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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 <tt class="computeroutput"><span class="identifier">T</span></tt> must be a complete
+ <span class="bold"><strong>Inherits:</strong></span> 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 <code class="computeroutput"><span class="identifier">T</span></code> must be a complete
         type.
       </p>
 <p>
         These two traits are synonyms for each other.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
 <p>
- Without some (as yet unspecified) help from the compiler, <tt class="computeroutput"><span class="identifier">has_nothrow_copy</span></tt>
+ Without some (as yet unspecified) help from the compiler, <code class="computeroutput"><span class="identifier">has_nothrow_copy</span></code>
         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
+ C++ 8 has the necessary compiler intrinsics
         to ensure that this trait "just works".
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_nothrow_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -68,8 +68,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_nothrow_copy_constructor</title>
+<title>has_nothrow_copy_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_nothrow_copy.html" title=" has_nothrow_copy">
-<link rel="next" href="has_no_throw_def_cons.html" title=" has_nothrow_default_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_nothrow_copy.html" title="has_nothrow_copy">
+<link rel="next" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,9 +24,10 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_nothrow_cp_cons"></a> has_nothrow_copy_constructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_nothrow_cp_cons"></a> has_nothrow_copy_constructor
+</h3></div></div></div>
 <p>
- See has_nothrow_copy.
+ See has_nothrow_copy.
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -36,8 +37,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_trivial_assign</title>
+<title>has_trivial_assign</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_no_throw_def_cons.html" title=" has_nothrow_default_constructor">
-<link rel="next" href="has_trivial_constructor.html" title="
- has_trivial_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">
+<link rel="next" href="has_trivial_constructor.html" title="has_trivial_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,23 +24,24 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_assign"></a> has_trivial_assign</h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_assign"></a> has_trivial_assign
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_assign</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_assign</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- type with a trivial assignment-operator then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ type with a trivial assignment-operator then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         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 <tt class="computeroutput"><span class="identifier">memcpy</span></tt>.
+ can be safely replaced with a call to <code class="computeroutput"><span class="identifier">memcpy</span></code>.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
@@ -49,26 +49,26 @@
         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
+ 9 and Visual C++ 8 have the necessary compiler intrinsics
         to detect user-defined classes with trivial constructors.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 12.8p11.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.8p11.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -77,7 +77,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -86,7 +86,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -96,7 +96,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -106,7 +106,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -119,8 +119,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- has_trivial_constructor</title>
+<title>has_trivial_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_assign.html" title=" has_trivial_assign">
-<link rel="next" href="has_trivial_copy.html" title=" has_trivial_copy">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_assign.html" title="has_trivial_assign">
+<link rel="next" href="has_trivial_copy.html" title="has_trivial_copy">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,20 +24,20 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_constructor"></a><a href="has_trivial_constructor.html" title="
- has_trivial_constructor">
- has_trivial_constructor</a></h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_constructor"></a><a href="has_trivial_constructor.html" title="has_trivial_constructor">
+ has_trivial_constructor</a>
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_default_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- type with a trivial default-constructor then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ type with a trivial default-constructor then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         These two traits are synonyms for each other.
@@ -51,7 +50,7 @@
         some benefit in terms of code size and speed can be obtained.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
@@ -59,25 +58,25 @@
         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
+ 9 and Visual C++ 8 have the necessary compiler intrinsics
         to detect user-defined classes with trivial constructors.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 12.1p6.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.1p6.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_constructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -86,8 +85,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -96,7 +95,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -106,7 +105,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -116,8 +115,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt>
- is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_constructor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
+ is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -130,8 +129,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_trivial_copy</title>
+<title>has_trivial_copy</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_constructor.html" title="
- has_trivial_constructor">
-<link rel="next" href="has_trivial_cp_cons.html" title=" has_trivial_copy_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_constructor.html" title="has_trivial_constructor">
+<link rel="next" href="has_trivial_cp_cons.html" title="has_trivial_copy_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,18 +24,19 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_copy"></a> has_trivial_copy</h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_copy"></a> has_trivial_copy
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_copy</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_copy</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_copy_constructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- type with a trivial copy-constructor then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ type with a trivial copy-constructor then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         These two traits are synonyms for each other.
@@ -44,10 +44,10 @@
 <p>
         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 <tt class="computeroutput"><span class="identifier">memcpy</span></tt>.
+ can be safely replaced with a call to <code class="computeroutput"><span class="identifier">memcpy</span></code>.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
@@ -55,26 +55,26 @@
         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
+ 9 and Visual C++ 8 have the necessary compiler intrinsics
         to detect user-defined classes with trivial constructors.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 12.8p6.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.8p6.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -83,7 +83,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -92,7 +92,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -102,7 +102,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -112,7 +112,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_copy</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -125,8 +125,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_trivial_copy_constructor</title>
+<title>has_trivial_copy_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_copy.html" title=" has_trivial_copy">
-<link rel="next" href="has_trivial_def_cons.html" title=" has_trivial_default_constructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_copy.html" title="has_trivial_copy">
+<link rel="next" href="has_trivial_def_cons.html" title="has_trivial_default_constructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,9 +24,10 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_cp_cons"></a> has_trivial_copy_constructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_cp_cons"></a> has_trivial_copy_constructor
+</h3></div></div></div>
 <p>
- See has_trivial_copy.
+ See has_trivial_copy.
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -36,8 +37,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_trivial_default_constructor</title>
+<title>has_trivial_default_constructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_cp_cons.html" title=" has_trivial_copy_constructor">
-<link rel="next" href="has_trivial_destructor.html" title=" has_trivial_destructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_cp_cons.html" title="has_trivial_copy_constructor">
+<link rel="next" href="has_trivial_destructor.html" title="has_trivial_destructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,10 +24,10 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_def_cons"></a> has_trivial_default_constructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_def_cons"></a> has_trivial_default_constructor
+</h3></div></div></div>
 <p>
- See <a href="has_trivial_constructor.html" title="
- has_trivial_constructor">has_trivial_constructor</a>.
+ See has_trivial_constructor.
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -37,8 +37,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_trivial_destructor</title>
+<title>has_trivial_destructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_def_cons.html" title=" has_trivial_default_constructor">
-<link rel="next" href="has_virtual_destructor.html" title=" has_virtual_destructor">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_def_cons.html" title="has_trivial_default_constructor">
+<link rel="next" href="has_virtual_destructor.html" title="has_virtual_destructor">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,15 +24,16 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_trivial_destructor"></a> has_trivial_destructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_trivial_destructor"></a> has_trivial_destructor
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_trivial_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_trivial_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- type with a trivial destructor then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ type with a trivial destructor then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         If a type has a trivial destructor then the destructor has no effect: calls
@@ -42,7 +43,7 @@
         some benefit in terms of code size and speed can be obtained.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
@@ -50,25 +51,25 @@
         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
+ 9 and Visual C++ 8 have the necessary compiler intrinsics
         to detect user-defined classes with trivial constructors.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 12.4p3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.4p3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_trivial_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -77,8 +78,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -87,7 +88,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">long</span><span class="special">)&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -97,7 +98,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -107,8 +108,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt>
- is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">has_trivial_destructor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
+ is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -121,8 +122,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> has_virtual_destructor</title>
+<title>has_virtual_destructor</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_trivial_destructor.html" title=" has_trivial_destructor">
-<link rel="next" href="integral_constant.html" title=" integral_constant">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_trivial_destructor.html" title="has_trivial_destructor">
+<link rel="next" href="integral_constant.html" title="integral_constant">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,33 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_virtual_destructor"></a> has_virtual_destructor</h3></div></div></div>
+<a name="boost_typetraits.reference.has_virtual_destructor"></a> has_virtual_destructor
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_virtual_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">has_virtual_destructor</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- type with a virtual destructor then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ type with a virtual destructor then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> This trait is provided
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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,
+ 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
+ the compiler used has compiler intrinsics
         that enable the trait to do the right thing: currently (May 2005) only Visual
- C++ 8 has the necessary intrinsics.
+ C++ 8 has the necessary intrinsics.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 12.4.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 12.4.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_virtual_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_virtual_destructor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -60,8 +61,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> integral_constant</title>
+<title>integral_constant</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="has_virtual_destructor.html" title=" has_virtual_destructor">
-<link rel="next" href="integral_promotion.html" title=" integral_promotion">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_virtual_destructor.html" title="has_virtual_destructor">
+<link rel="next" href="integral_promotion.html" title="integral_promotion">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.integral_constant"></a> integral_constant</h3></div></div></div>
+<a name="boost_typetraits.reference.integral_constant"></a> integral_constant
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">val</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">integral_constant</span>
@@ -38,9 +39,9 @@
 <span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">false</span><span class="special">&gt;</span> <span class="identifier">false_type</span><span class="special">;</span>
 </pre>
 <p>
- Class template <tt class="computeroutput"><span class="identifier">integral_constant</span></tt>
+ Class template <code class="computeroutput"><span class="identifier">integral_constant</span></code>
         is the common base class for all the value-based type traits. The two typedef's
- <tt class="computeroutput"><span class="identifier">true_type</span></tt> and <tt class="computeroutput"><span class="identifier">false_type</span></tt> are provided for convenience:
+ <code class="computeroutput"><span class="identifier">true_type</span></code> and <code class="computeroutput"><span class="identifier">false_type</span></code> are provided for convenience:
         most of the value traits are Boolean properties and so will inherit from
         one of these.
       </p>
@@ -52,8 +53,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> integral_promotion</title>
+<title>integral_promotion</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="integral_constant.html" title=" integral_constant">
-<link rel="next" href="is_abstract.html" title=" is_abstract">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="integral_constant.html" title="integral_constant">
+<link rel="next" href="is_abstract.html" title="is_abstract">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,33 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.integral_promotion"></a> integral_promotion</h3></div></div></div>
+<a name="boost_typetraits.reference.integral_promotion"></a> integral_promotion
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">integral_promotion</span>
 <span class="special">{</span>
- <span class="keyword">typedef</span> <i class="replaceable"><tt>see-below</tt></i> <span class="identifier">type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
- <span class="bold"><b>type:</b></span> If integral promotion can be applied
- to an rvalue of type <tt class="computeroutput"><span class="identifier">T</span></tt>, then
- applies integral promotion to <tt class="computeroutput"><span class="identifier">T</span></tt>
- and keeps cv-qualifiers of <tt class="computeroutput"><span class="identifier">T</span></tt>,
- otherwise leaves <tt class="computeroutput"><span class="identifier">T</span></tt> unchanged.
+ <span class="bold"><strong>type:</strong></span> If integral promotion can be applied
+ to an rvalue of type <code class="computeroutput"><span class="identifier">T</span></code>, then
+ applies integral promotion to <code class="computeroutput"><span class="identifier">T</span></code>
+ and keeps cv-qualifiers of <code class="computeroutput"><span class="identifier">T</span></code>,
+ otherwise leaves <code class="computeroutput"><span class="identifier">T</span></code> unchanged.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 4.5 except 4.5/3
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 4.5 except 4.5/3
         (integral bit-field).
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">integral_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">integral_promotion</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id482141"></a><p class="title"><b>Table 1.14. Examples</b></p>
-<table class="table" summary="Examples">
+<a name="id516064"></a><p class="title"><b>Table 1.14. Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
 <col>
@@ -71,43 +72,44 @@
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">short</span>
- <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">short</span>
+ <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">short</span><span class="special">&amp;</span></tt>
+ <code class="computeroutput"><span class="keyword">short</span><span class="special">&amp;</span></code>
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
- <tt class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">enum</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">float_round_style</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
+ <code class="computeroutput"><span class="identifier">integral_promotion</span><span class="special">&lt;</span><span class="keyword">enum</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">float_round_style</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
             </p>
             </td>
 <td>
             <p>
- <tt class="computeroutput"><span class="keyword">int</span></tt>
+ <code class="computeroutput"><span class="keyword">int</span></code>
             </p>
             </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
+<br class="table-break">
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -116,8 +118,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_abstract</title>
+<title>is_abstract</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="integral_promotion.html" title=" integral_promotion">
-<link rel="next" href="is_arithmetic.html" title=" is_arithmetic">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="integral_promotion.html" title="integral_promotion">
+<link rel="next" href="is_arithmetic.html" title="is_arithmetic">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,28 +24,29 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_abstract"></a> is_abstract</h3></div></div></div>
+<a name="boost_typetraits.reference.is_abstract"></a> is_abstract
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_abstract</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_abstract</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- abstract type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ abstract type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 10.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 10.3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_abstract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_abstract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> The compiler must
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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;
+ 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
@@ -53,13 +54,13 @@
         their particular use-case.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- Given: <tt class="computeroutput"><span class="keyword">class</span> <span class="identifier">abc</span><span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">abc</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">};</span></tt>
+ Given: <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">abc</span><span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">abc</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">};</span></code>
           </p>
 <p>
         </p>
@@ -68,8 +69,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -78,7 +79,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -87,7 +88,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">abc</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -97,7 +98,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_abstract</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -110,8 +111,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_arithmetic</title>
+<title>is_arithmetic</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_abstract.html" title=" is_abstract">
-<link rel="next" href="is_array.html" title=" is_array">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_abstract.html" title="is_abstract">
+<link rel="next" href="is_array.html" title="is_array">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,35 +24,36 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_arithmetic"></a> is_arithmetic</h3></div></div></div>
+<a name="boost_typetraits.reference.is_arithmetic"></a> is_arithmetic
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_arithmetic</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_arithmetic</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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).
+ <span class="bold"><strong>Inherits:</strong></span> 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).
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.1p8.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p8.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -61,7 +62,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -70,7 +71,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -80,7 +81,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -93,8 +94,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_array</title>
+<title>is_array</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_arithmetic.html" title=" is_arithmetic">
-<link rel="next" href="is_base_of.html" title=" is_base_of">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_arithmetic.html" title="is_arithmetic">
+<link rel="next" href="is_base_of.html" title="is_base_of">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,38 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_array"></a> is_array</h3></div></div></div>
+<a name="boost_typetraits.reference.is_array"></a> is_array
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_array</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_array</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- array type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ array type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 8.3.4.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.4.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can give the wrong result with function types.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">2</span><span class="special">]&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -63,8 +64,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -73,7 +74,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">[]&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">[]&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -83,7 +84,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -96,8 +97,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_base_of</title>
+<title>is_base_of</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_array.html" title=" is_array">
-<link rel="next" href="is_class.html" title=" is_class">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_array.html" title="is_array">
+<link rel="next" href="is_class.html" title="is_class">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,56 +24,57 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_base_of"></a> is_base_of</h3></div></div></div>
+<a name="boost_typetraits.reference.is_base_of"></a> is_base_of
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_base_of</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_base_of</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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.
+ <span class="bold"><strong>Inherits:</strong></span> 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.
       </p>
 <p>
         This template will detect non-public base classes, and ambiguous base classes.
       </p>
 <p>
- Note that <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">,</span><span class="identifier">X</span><span class="special">&gt;</span></tt> will always inherit from true_type.
- <span class="bold"><b>This is the case even if <tt class="computeroutput"><span class="identifier">X</span></tt>
- is not a class type</b></span>. This is a change in behaviour from Boost-1.33
+ Note that <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">,</span><span class="identifier">X</span><span class="special">&gt;</span></code> will always inherit from true_type.
+ <span class="bold"><strong>This is the case even if <code class="computeroutput"><span class="identifier">X</span></code>
+ is not a class type</strong></span>. This is a change in behaviour from Boost-1.33
         in order to track the Technical Report on C++ Library Extensions.
       </p>
 <p>
- Types <tt class="computeroutput"><span class="identifier">Base</span></tt> and <tt class="computeroutput"><span class="identifier">Derived</span></tt> must not be incomplete types.
+ Types <code class="computeroutput"><span class="identifier">Base</span></code> and <code class="computeroutput"><span class="identifier">Derived</span></code> must not be incomplete types.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 10.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 10.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_base_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_base_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <tt class="computeroutput"><span class="identifier">Base</span></tt>
- is a private base class of <tt class="computeroutput"><span class="identifier">Derived</span></tt>,
- or if <tt class="computeroutput"><span class="identifier">Base</span></tt> is an ambiguous
- base of <tt class="computeroutput"><span class="identifier">Derived</span></tt>. These compilers
+ will produce compiler errors if <code class="computeroutput"><span class="identifier">Base</span></code>
+ is a private base class of <code class="computeroutput"><span class="identifier">Derived</span></code>,
+ or if <code class="computeroutput"><span class="identifier">Base</span></code> is an ambiguous
+ base of <code class="computeroutput"><span class="identifier">Derived</span></code>. These compilers
         include Borland C++, older versions of Sun Forte C++, Digital Mars C++, and
         older versions of EDG based compilers.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- Given: <tt class="computeroutput"> <span class="keyword">class</span> <span class="identifier">Base</span><span class="special">{};</span> <span class="keyword">class</span> <span class="identifier">Derived</span> <span class="special">:</span>
- <span class="keyword">public</span> <span class="identifier">Base</span><span class="special">{};</span></tt>
+ Given: <code class="computeroutput"> <span class="keyword">class</span> <span class="identifier">Base</span><span class="special">{};</span> <span class="keyword">class</span> <span class="identifier">Derived</span> <span class="special">:</span>
+ <span class="keyword">public</span> <span class="identifier">Base</span><span class="special">{};</span></code>
           </p>
 <p>
         </p>
@@ -82,8 +83,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -92,7 +93,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -101,7 +102,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -111,7 +112,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Derived</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -121,7 +122,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Base</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">Base</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>: a class is regarded as it's
             own base.
           </p>
@@ -132,7 +133,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_base_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -145,8 +146,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_class</title>
+<title>is_class</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_base_of.html" title=" is_base_of">
-<link rel="next" href="is_complex.html" title=" is_complex">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_base_of.html" title="is_base_of">
+<link rel="next" href="is_complex.html" title="is_complex">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,40 +24,41 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_class"></a> is_class</h3></div></div></div>
+<a name="boost_typetraits.reference.is_class"></a> is_class
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_class</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_class</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- class type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ class type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 9.2.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 9.2.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_class</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_class</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> Without (some as
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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
+ 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.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- Given: <tt class="computeroutput"><span class="keyword">class</span> <span class="identifier">MyClass</span><span class="special">;</span></tt> then:
+ Given: <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">MyClass</span><span class="special">;</span></code> then:
           </p>
 <p>
         </p>
@@ -66,8 +67,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -76,8 +77,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -86,7 +87,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -96,7 +97,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -106,7 +107,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">*&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -116,7 +117,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -129,8 +130,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_complex</title>
+<title>is_complex</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_class.html" title=" is_class">
-<link rel="next" href="is_compound.html" title=" is_compound">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_class.html" title="is_class">
+<link rel="next" href="is_compound.html" title="is_compound">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,24 +24,25 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_complex"></a> is_complex</h3></div></div></div>
+<a name="boost_typetraits.reference.is_complex"></a> is_complex
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_complex</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_complex</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If <tt class="computeroutput"><span class="identifier">T</span></tt>
- is a complex number type then true (of type <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span></tt>
- for some type <tt class="computeroutput"><span class="identifier">U</span></tt>), otherwise
+ <span class="bold"><strong>Inherits:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code>
+ is a complex number type then true (of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span></code>
+ for some type <code class="computeroutput"><span class="identifier">U</span></code>), otherwise
         false.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 26.2.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 26.2.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -51,8 +52,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_compound</title>
+<title>is_compound</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_complex.html" title=" is_complex">
-<link rel="next" href="is_const.html" title=" is_const">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_complex.html" title="is_complex">
+<link rel="next" href="is_const.html" title="is_const">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,34 +24,35 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_compound"></a> is_compound</h3></div></div></div>
+<a name="boost_typetraits.reference.is_compound"></a> is_compound
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_compound</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_compound</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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).
+ <span class="bold"><strong>Inherits:</strong></span> 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).
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_compound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_compound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">MyClass</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -60,7 +61,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">MyEnum</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">MyEnum</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -69,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -79,7 +80,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -89,7 +90,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -99,7 +100,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_compound</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -112,8 +113,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_const</title>
+<title>is_const</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_compound.html" title=" is_compound">
-<link rel="next" href="is_convertible.html" title=" is_convertible">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_compound.html" title="is_compound">
+<link rel="next" href="is_convertible.html" title="is_convertible">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,32 +24,33 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_const"></a> is_const</h3></div></div></div>
+<a name="boost_typetraits.reference.is_const"></a> is_const
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_const</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_const</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (top level) const-qualified
- type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (top level) const-qualified
+ type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -58,7 +59,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -67,7 +68,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -77,7 +78,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
             the const-qualifier is not at the top level in this case.
           </p>
@@ -88,7 +89,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
             the const-qualifier is not at the top level in this case.
           </p>
@@ -99,7 +100,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -109,7 +110,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -122,8 +123,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_convertible</title>
+<title>is_convertible</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_const.html" title=" is_const">
-<link rel="next" href="is_empty.html" title=" is_empty">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_const.html" title="is_const">
+<link rel="next" href="is_empty.html" title="is_empty">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,16 +24,17 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_convertible"></a> is_convertible</h3></div></div></div>
+<a name="boost_typetraits.reference.is_convertible"></a> is_convertible
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_convertible</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_convertible</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If an imaginary lvalue of type
- <tt class="computeroutput"><span class="identifier">From</span></tt> is convertible to type
- <tt class="computeroutput"><span class="identifier">To</span></tt> then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If an imaginary lvalue of type
+ <code class="computeroutput"><span class="identifier">From</span></code> is convertible to type
+ <code class="computeroutput"><span class="identifier">To</span></code> then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         Type From must not be an incomplete type.
@@ -46,12 +47,12 @@
         types.
       </p>
 <p>
- This template can not detect whether a converting-constructor is <tt class="computeroutput"><span class="keyword">public</span></tt> or not: if type <tt class="computeroutput"><span class="identifier">To</span></tt>
- has a <tt class="computeroutput"><span class="keyword">private</span></tt> converting constructor
- from type <tt class="computeroutput"><span class="identifier">From</span></tt> then instantiating
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">&gt;</span></tt>
- will produce a compiler error. For this reason <tt class="computeroutput"><span class="identifier">is_convertible</span></tt>
- can not be used to determine whether a type has a <tt class="computeroutput"><span class="keyword">public</span></tt>
+ This template can not detect whether a converting-constructor is <code class="computeroutput"><span class="keyword">public</span></code> or not: if type <code class="computeroutput"><span class="identifier">To</span></code>
+ has a <code class="computeroutput"><span class="keyword">private</span></code> converting constructor
+ from type <code class="computeroutput"><span class="identifier">From</span></code> then instantiating
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">&gt;</span></code>
+ will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">is_convertible</span></code>
+ can not be used to determine whether a type has a <code class="computeroutput"><span class="keyword">public</span></code>
         copy-constructor or not.
       </p>
 <p>
@@ -67,30 +68,30 @@
 </span><span class="keyword">bool</span> <span class="keyword">const</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">*,</span><span class="identifier">A</span><span class="special">*&gt;::</span><span class="identifier">value</span><span class="special">;</span>
 </pre>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 4 and 8.5.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 4 and 8.5.
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> This template is
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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 <tt class="computeroutput">is_abstract</tt>,
- then the template parameter <tt class="computeroutput"><span class="identifier">To</span></tt>
+ If the compiler does not support <code class="computeroutput">is_abstract</code>,
+ then the template parameter <code class="computeroutput"><span class="identifier">To</span></code>
         must not be an abstract type.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_convertible</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_convertible</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -99,8 +100,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -109,7 +110,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">,</span> <span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*</span> <span class="keyword">const</span><span class="special">,</span> <span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -119,9 +120,9 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
- the conversion would require a <tt class="computeroutput"><span class="keyword">const_cast</span></tt>.
+ the conversion would require a <code class="computeroutput"><span class="keyword">const_cast</span></code>.
           </p>
 <p>
         </p>
@@ -130,7 +131,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">long</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">long</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -140,7 +141,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -150,7 +151,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -163,8 +164,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_empty</title>
+<title>is_empty</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_convertible.html" title=" is_convertible">
-<link rel="next" href="is_enum.html" title=" is_enum">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_convertible.html" title="is_convertible">
+<link rel="next" href="is_enum.html" title="is_enum">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,26 +24,27 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_empty"></a> is_empty</h3></div></div></div>
+<a name="boost_typetraits.reference.is_empty"></a> is_empty
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_empty</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_empty</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is an empty class type then
- inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is an empty class type then
+ inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 10p5.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 10p5.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> In order to correctly
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> In order to correctly
         detect empty classes this trait relies on either:
       </p>
 <div class="itemizedlist"><ul type="disc">
@@ -51,7 +52,7 @@
           the compiler implementing zero sized empty base classes, or
         </li>
 <li>
- the compiler providing intrinsics
+ the compiler providing intrinsics
           to detect empty classes.
         </li>
 </ul></div>
@@ -66,14 +67,14 @@
         then this template can not be used with abstract types.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- Given: <tt class="computeroutput"><span class="keyword">struct</span> <span class="identifier">empty_class</span>
- <span class="special">{};</span></tt>
+ Given: <code class="computeroutput"><span class="keyword">struct</span> <span class="identifier">empty_class</span>
+ <span class="special">{};</span></code>
           </p>
 <p>
         </p>
@@ -82,8 +83,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -92,8 +93,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -102,7 +103,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">empty_class</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -112,7 +113,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_empty</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -125,8 +126,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_enum</title>
+<title>is_enum</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_empty.html" title=" is_empty">
-<link rel="next" href="is_floating_point.html" title=" is_floating_point">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_empty.html" title="is_empty">
+<link rel="next" href="is_floating_point.html" title="is_floating_point">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,40 +24,41 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_enum"></a> is_enum</h3></div></div></div>
+<a name="boost_typetraits.reference.is_enum"></a> is_enum
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_enum</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_enum</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- enum type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ enum type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 7.2.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 7.2.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_enum</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_enum</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> Requires a correctly
- functioning is_convertible
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> 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.
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- Given: <tt class="computeroutput"><span class="keyword">enum</span> <span class="identifier">my_enum</span>
- <span class="special">{</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span> <span class="special">};</span></tt>
+ Given: <code class="computeroutput"><span class="keyword">enum</span> <span class="identifier">my_enum</span>
+ <span class="special">{</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span> <span class="special">};</span></code>
           </p>
 <p>
         </p>
@@ -66,8 +67,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -76,8 +77,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -86,7 +87,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -96,7 +97,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -106,7 +107,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">*&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">my_enum</span><span class="special">*&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>.
           </p>
 <p>
@@ -116,7 +117,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_enum</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -129,8 +130,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_floating_point</title>
+<title>is_floating_point</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_enum.html" title=" is_enum">
-<link rel="next" href="is_function.html" title=" is_function">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_enum.html" title="is_enum">
+<link rel="next" href="is_function.html" title="is_function">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,33 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_floating_point"></a> is_floating_point</h3></div></div></div>
+<a name="boost_typetraits.reference.is_floating_point"></a> is_floating_point
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_floating_point</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_floating_point</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- floating point type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ floating point type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.1p8.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p8.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_floating_point</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_floating_point</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -59,7 +60,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -68,7 +69,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -78,7 +79,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_floating_point</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -91,8 +92,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_function</title>
+<title>is_function</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_floating_point.html" title=" is_floating_point">
-<link rel="next" href="is_fundamental.html" title=" is_fundamental">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_floating_point.html" title="is_floating_point">
+<link rel="next" href="is_fundamental.html" title="is_fundamental">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,17 +24,18 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_function"></a> is_function</h3></div></div></div>
+<a name="boost_typetraits.reference.is_function"></a> is_function
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_function</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_function</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- function type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> 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 <span class="emphasis"><em>pointers to functions</em></span>,
- or <span class="emphasis"><em>references to functions</em></span>, these are detected by is_pointer and is_reference respectively:
+ or <span class="emphasis"><em>references to functions</em></span>, these are detected by is_pointer and is_reference respectively:
       </p>
 <pre class="programlisting">
 <span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">f1</span><span class="special">();</span> <span class="comment">// f1 is of function type.
@@ -42,22 +43,22 @@
 </span><span class="keyword">typedef</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">f3</span><span class="special">&amp;)();</span> <span class="comment">// f3 is a reference to a function.
 </span></pre>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2p1 and 8.3.5.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2p1 and 8.3.5.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -66,7 +67,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -75,7 +76,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -85,7 +86,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case
             is a pointer type, not a function type.
           </p>
@@ -96,7 +97,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(&amp;)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(&amp;)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case
             is a reference to a function, not a function type.
           </p>
@@ -107,7 +108,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>: the argument in this case
             is a pointer to a member function.
           </p>
@@ -118,7 +119,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_function</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -128,46 +129,45 @@
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/html/images/tip.png"></td>
 <th align="left">Tip</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
 <p>
           Don't confuse function-types with pointers to functions:
         </p>
 <p>
- <tt class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">int</span>
- <span class="identifier">f</span><span class="special">(</span><span class="keyword">double</span><span class="special">);</span></tt>
+ <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">int</span>
+ <span class="identifier">f</span><span class="special">(</span><span class="keyword">double</span><span class="special">);</span></code>
         </p>
 <p>
           defines a function type,
         </p>
 <p>
- <tt class="computeroutput"><span class="identifier">f</span> <span class="identifier">foo</span><span class="special">;</span></tt>
+ <code class="computeroutput"><span class="identifier">f</span> <span class="identifier">foo</span><span class="special">;</span></code>
         </p>
 <p>
- declares a prototype for a function of type <tt class="computeroutput"><span class="identifier">f</span></tt>,
+ declares a prototype for a function of type <code class="computeroutput"><span class="identifier">f</span></code>,
         </p>
 <p>
- <tt class="computeroutput"><span class="identifier">f</span><span class="special">*</span>
+ <code class="computeroutput"><span class="identifier">f</span><span class="special">*</span>
           <span class="identifier">pf</span> <span class="special">=</span>
- <span class="identifier">foo</span><span class="special">;</span></tt>
+ <span class="identifier">foo</span><span class="special">;</span></code>
         </p>
 <p>
- <tt class="computeroutput"><span class="identifier">f</span><span class="special">&amp;</span>
+ <code class="computeroutput"><span class="identifier">f</span><span class="special">&amp;</span>
           <span class="identifier">fr</span> <span class="special">=</span>
- <span class="identifier">foo</span><span class="special">;</span></tt>
+ <span class="identifier">foo</span><span class="special">;</span></code>
         </p>
 <p>
- declares a pointer and a reference to the function <tt class="computeroutput"><span class="identifier">foo</span></tt>.
+ declares a pointer and a reference to the function <code class="computeroutput"><span class="identifier">foo</span></code>.
         </p>
 <p>
           If you want to detect whether some type is a pointer-to-function then use:
         </p>
 <p>
- <tt class="computeroutput">is_function<span class="special">&lt;</span>remove_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span>
- <span class="special">&amp;&amp;</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput">is_function<span class="special">&lt;</span>remove_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span>
+ <span class="special">&amp;&amp;</span> is_pointer<span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
         </p>
 <p>
- or for pointers to member functions you can just use <a href="is_member_function_pointer.html" title="
- is_member_function_pointer">is_member_function_pointer</a>
+ or for pointers to member functions you can just use is_member_function_pointer
           directly.
         </p>
 </td></tr>
@@ -180,8 +180,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_fundamental</title>
+<title>is_fundamental</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_function.html" title=" is_function">
-<link rel="next" href="is_integral.html" title=" is_integral">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_function.html" title="is_function">
+<link rel="next" href="is_integral.html" title="is_integral">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,38 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_fundamental"></a> is_fundamental</h3></div></div></div>
+<a name="boost_typetraits.reference.is_fundamental"></a> is_fundamental
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_fundamental</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_fundamental</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- fundamental type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> 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)
+ is_integral,
+ is_floating_point
+ and is_void)
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.1.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_fundamental</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_fundamental</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">)&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">)&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -63,8 +64,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">double</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">double</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -73,7 +74,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -83,7 +84,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_fundamental</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -96,8 +97,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_integral</title>
+<title>is_integral</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_fundamental.html" title=" is_fundamental">
-<link rel="next" href="is_member_function_pointer.html" title="
- is_member_function_pointer">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_fundamental.html" title="is_fundamental">
+<link rel="next" href="is_member_function_pointer.html" title="is_member_function_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,33 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_integral"></a> is_integral</h3></div></div></div>
+<a name="boost_typetraits.reference.is_integral"></a> is_integral
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_integral</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_integral</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- integral type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ integral type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.1p7.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.1p7.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_integral</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_integral</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -60,8 +60,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -70,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">long</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="keyword">long</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -80,7 +80,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -93,8 +93,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- is_member_function_pointer</title>
+<title>is_member_function_pointer</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_integral.html" title=" is_integral">
-<link rel="next" href="is_member_object_pointer.html" title="
- is_member_object_pointer">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_integral.html" title="is_integral">
+<link rel="next" href="is_member_object_pointer.html" title="is_member_object_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,34 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_member_function_pointer"></a><a href="is_member_function_pointer.html" title="
- is_member_function_pointer">
- is_member_function_pointer</a></h3></div></div></div>
+<a name="boost_typetraits.reference.is_member_function_pointer"></a><a href="is_member_function_pointer.html" title="is_member_function_pointer">
+ is_member_function_pointer</a>
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_member_function_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_member_function_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- pointer to a member function then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ pointer to a member function then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 8.3.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_function_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_function_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -62,8 +60,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -72,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -82,12 +80,11 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
             the argument in this case is a pointer to a data member and not a member
- function, see <a href="is_member_object_pointer.html" title="
- is_member_object_pointer">is_member_object_pointer</a>
- and is_member_pointer
+ function, see is_member_object_pointer
+ and is_member_pointer
           </p>
 <p>
         </p>
@@ -96,8 +93,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt>
- is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_member_function_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
+ is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -110,8 +107,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,15 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>
- is_member_object_pointer</title>
+<title>is_member_object_pointer</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_member_function_pointer.html" title="
- is_member_function_pointer">
-<link rel="next" href="is_member_pointer.html" title=" is_member_pointer">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_member_function_pointer.html" title="is_member_function_pointer">
+<link rel="next" href="is_member_pointer.html" title="is_member_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -26,34 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_member_object_pointer"></a><a href="is_member_object_pointer.html" title="
- is_member_object_pointer">
- is_member_object_pointer</a></h3></div></div></div>
+<a name="boost_typetraits.reference.is_member_object_pointer"></a><a href="is_member_object_pointer.html" title="is_member_object_pointer">
+ is_member_object_pointer</a>
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_member_object_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_member_object_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> 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.
+ <span class="bold"><strong>Inherits:</strong></span> 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.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 8.3.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_object_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_object_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;</span></tt> inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;</span></code> inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -62,8 +60,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">double</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">type</span></tt>
- is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">double</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">type</span></code>
+ is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -72,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -82,12 +80,11 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
             the argument in this case is a pointer to a member function and not a
- member object, see <a href="is_member_function_pointer.html" title="
- is_member_function_pointer">is_member_function_pointer</a>
- and is_member_pointer
+ member object, see is_member_function_pointer
+ and is_member_pointer
           </p>
 <p>
         </p>
@@ -96,8 +93,8 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt>
- is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_member_object_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
+ is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -110,8 +107,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,14 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_member_pointer</title>
+<title>is_member_pointer</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_member_object_pointer.html" title="
- is_member_object_pointer">
-<link rel="next" href="is_object.html" title=" is_object">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_member_object_pointer.html" title="is_member_object_pointer">
+<link rel="next" href="is_object.html" title="is_object">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -25,34 +24,35 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_member_pointer"></a> is_member_pointer</h3></div></div></div>
+<a name="boost_typetraits.reference.is_member_pointer"></a> is_member_pointer
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_member_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_member_pointer</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
+ <span class="bold"><strong>Inherits:</strong></span> 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.
+ true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9.2 and 8.3.3.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.2 and 8.3.3.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_member_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -61,7 +61,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">char</span><span class="special">)&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -70,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -80,7 +80,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_member_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -93,8 +93,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_object</title>
+<title>is_object</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_member_pointer.html" title=" is_member_pointer">
-<link rel="next" href="is_pod.html" title=" is_pod">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_member_pointer.html" title="is_member_pointer">
+<link rel="next" href="is_pod.html" title="is_pod">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,34 +24,35 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_object"></a> is_object</h3></div></div></div>
+<a name="boost_typetraits.reference.is_object"></a> is_object
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_object</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_object</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- object type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> 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.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9p9.
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p9.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_object</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_object</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -60,7 +61,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -69,7 +70,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(*)(</span><span class="keyword">void</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -79,7 +80,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="identifier">MyClass</span><span class="special">::*)(</span><span class="keyword">void</span><span class="special">)</span><span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>true</em></span>.
           </p>
 <p>
@@ -89,7 +90,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">&amp;&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">&amp;&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>: reference types are not
             objects
           </p>
@@ -100,7 +101,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">double</span><span class="special">)&gt;::</span><span class="identifier">value</span></tt> is an integral constant expression
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">double</span><span class="special">)&gt;::</span><span class="identifier">value</span></code> is an integral constant expression
             that evaluates to <span class="emphasis"><em>false</em></span>: function types are not
             objects
           </p>
@@ -111,7 +112,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">value</span></tt>
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
             is an integral constant expression that evaluates to <span class="emphasis"><em>false</em></span>:
             void is not an object type
           </p>
@@ -122,7 +123,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></tt> is the type <tt class="computeroutput"><span class="keyword">bool</span></tt>.
+ <code class="computeroutput"><span class="identifier">is_object</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code> is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
           </p>
 <p>
         </p>
@@ -135,8 +136,7 @@
       Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
       Ramey and Jeremy Siek<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org class="emphasis"><em>LICENSE_1_0.txt"&gt;
- http:</em></span>/www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
+ file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
       </p></small></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html
==============================================================================
--- trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html (original)
+++ trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html 2007-11-08 04:38:22 EST (Thu, 08 Nov 2007)
@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> is_pod</title>
+<title>is_pod</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
 <link rel="start" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
-<link rel="up" href="../reference.html" title=" Alphabetical Reference">
-<link rel="prev" href="is_object.html" title=" is_object">
-<link rel="next" href="is_pointer.html" title=" is_pointer">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="is_object.html" title="is_object">
+<link rel="next" href="is_pointer.html" title="is_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,15 +24,16 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.is_pod"></a> is_pod</h3></div></div></div>
+<a name="boost_typetraits.reference.is_pod"></a> is_pod
+</h3></div></div></div>
 <pre class="programlisting">
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_pod</span> <span class="special">:</span> <span class="keyword">public</span> <i class="replaceable"><tt>true_type-or-false_type</tt></i> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_pod</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code>true_type-or-false_type</code></em> <span class="special">{};</span>
 </pre>
 <p>
- <span class="bold"><b>Inherits:</b></span> If T is a (possibly cv-qualified)
- POD type then inherits from true_type,
- otherwise inherits from false_type.
+ <span class="bold"><strong>Inherits:</strong></span> If T is a (possibly cv-qualified)
+ POD type then inherits from true_type,
+ otherwise inherits from false_type.
       </p>
 <p>
         POD stands for "Plain old data". Arithmetic types, and enumeration
@@ -44,11 +45,11 @@
         array of PODs.
       </p>
 <p>
- <span class="bold"><b>C++ Standard Reference:</b></span> 3.9p10 and 9p4 (Note
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9p10 and 9p4 (Note
         that POD's are also aggregates, see 8.5.1).
       </p>
 <p>
- <span class="bold"><b>Compiler Compatibility:</b></span> If the compiler
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler
         does not support partial-specialization of class templates, then this template
         can not be used with function types.
       </p>
@@ -59,19 +60,19 @@
         the necessary compiler-</span>_intrinsics.
       </p>
 <p>
- <span class="bold"><b>Header:</b></span> <tt class="computeroutput"> <span class="preprocessor">#include</span>
- <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pod</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
- or <tt class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pod</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <p>
- <span class="bold"><b>Examples:</b></span>
+ <span class="bold"><strong>Examples:</strong></span>
       </p>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_pod</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></tt>
- inherits from <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_pod</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>
+ inherits from <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -80,7 +81,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_pod</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></tt> is the type <tt class="computeroutput">true_type</tt>.
+ <code class="computeroutput"><span class="identifier">is_pod</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">type</span></code> is the type <code class="computeroutput">true_type</code>.
           </p>
 <p>
         </p>
@@ -89,7 +90,7 @@
 <p>
           </p>
 <p>
- <tt class="computeroutput"><span class="identifier">is_pod</span><span class="special">&lt;</span><