This commit was manufactured by cvs2svn to create tag

'Version_1_34_0_RC3'. [SVN r37663]
Added links to PDF docs.
2007-05-11 03:40:35 +00:00 · 2007-05-09 17:20:56 +00:00 · 2007-01-15 10:42:05 +00:00 · 2006-12-22 10:09:37 +00:00 · 2006-12-12 16:14:41 +00:00 · 2006-11-06 17:10:46 +00:00
242 changed files with 21591 additions and 20880 deletions
--- a/c++_type_traits.htm
+++ b/c++_type_traits.htm
@ -1,590 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>C++ Type traits</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<h2 align="center">C++ Type traits</h2>
-
-<p align="center"><em>by John Maddock and Steve Cleary</em></p>
-
-<p align="center"><em>This is the draft version of an article
-that appeared in the October 2000 issue of </em><a
-href="http://www.ddj.com"><em>Dr Dobb's Journal</em></a></p>
-
-<p>Generic programming (writing code which works with any data
-type meeting a set of requirements) has become the method of
-choice for providing reusable code. However, there are times in
-generic programming when &quot;generic&quot; just isn't good
-enough - sometimes the differences between types are too large
-for an efficient generic implementation. This is when the traits
-technique becomes important - by encapsulating those properties
-that need to be considered on a type by type basis inside a
-traits class, we can minimise the amount of code that has to
-differ from one type to another, and maximise the amount of
-generic code.</p>
-
-<p>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 <font size="2"
-face="Courier New">strlen</font> and <font size="2"
-face="Courier New">wcslen</font> 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 realised this, and abstracted the properties of <font
-size="2" face="Courier New">char</font> and <font size="2"
-face="Courier New">wchar_t</font> into the class <font size="2"
-face="Courier New">char_traits</font>. Generic code that works
-with character strings can simply use <font size="2"
-face="Courier New">char_traits&lt;&gt;::length</font> to
-determine the length of a null terminated string, safe in the
-knowledge that specialisations of <font size="2"
-face="Courier New">char_traits</font> will use the most
-appropriate method available to them.</p>
-
-<h4>Type traits</h4>
-
-<p>Class <font size="2" face="Courier New">char_traits</font> is
-a classic example of a collection of type specific properties
-wrapped up in a single class - what Nathan Myers termed a <i>baggage
-class</i>[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 has a single member <i>value</i>,
-a compile-time constant that is true if the type has the
-specified property, and false otherwise. As we will show, these
-classes can be used in generic programming to determine the
-properties of a given type and introduce optimisations that are
-appropriate for that case.</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 <i>type</i> that is the result of the
-transformation. All of the type-traits classes are defined inside
-namespace <font size="2" face="Courier New">boost</font>; for
-brevity, namespace-qualification is omitted in most of the code
-samples given.</p>
-
-<h4>Implementation</h4>
-
-<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 flavour for how some of the classes are implemented.
-Beginning with possibly the simplest class in the library, is_void&lt;T&gt;
-has a member <i>value</i> that is true only if T is void.</p>
-
-<pre>template &lt;typename T&gt; 
-struct is_void
-{ static const bool value = false; };
-
-template &lt;&gt; 
-struct is_void&lt;void&gt;
-{ static const bool value = true; };</pre>
-
-<p>Here we define a primary version of the template class <font
-size="2" face="Courier New">is_void</font>, and provide a full-specialisation
-when T is void. While full specialisation of a template class is
-an important technique, sometimes we need a solution that is
-halfway between a fully generic solution, and a full
-specialisation. This is exactly the situation for which the
-standards committee defined partial template-class specialisation.
-As an example, consider the class boost::is_pointer&lt;T&gt;:
-here we needed a primary version that handles all the cases where
-T is not a pointer, and a partial specialisation to handle all
-the cases where T is a pointer:</p>
-
-<pre>template &lt;typename T&gt; 
-struct is_pointer 
-{ static const bool value = false; };
-
-template &lt;typename T&gt; 
-struct is_pointer&lt;T*&gt; 
-{ static const bool value = true; };</pre>
-
-<p>The syntax for partial specialisation is somewhat arcane and
-could easily occupy an article in its own right; like full
-specialisation, in order to write a partial specialisation for a
-class, you must first declare the primary template. The partial
-specialisation contains an extra &lt;&#133;&gt; after the class
-name that contains the partial specialisation parameters; these
-define the types that will bind to that partial specialisation
-rather than the default template. The rules for what can appear
-in a partial specialisation are somewhat convoluted, but as a
-rule of thumb if you can legally write two function overloads of
-the form:</p>
-
-<pre>void foo(T);
-void foo(U);</pre>
-
-<p>Then you can also write a partial specialisation of the form:</p>
-
-<pre>template &lt;typename T&gt;
-class c{ /*details*/ };
-
-template &lt;typename T&gt;
-
-class c&lt;U&gt;{ /*details*/ };</pre>
-
-<p>This rule is by no means foolproof, but it is reasonably
-simple to remember and close enough to the actual rule to be
-useful for everyday use.</p>
-
-<p>As a more complex example of partial specialisation consider
-the class remove_bounds&lt;T&gt;. This class defines a single
-typedef-member <i>type</i> 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>template &lt;typename T&gt; 
-struct remove_bounds
-{ typedef T type; };
-
-template &lt;typename T, std::size_t N&gt; 
-struct remove_bounds&lt;T[N]&gt;
-{ typedef T type; };</pre>
-
-<p>The aim of remove_bounds is this: imagine a generic algorithm
-that is passed an array type as a template parameter, <font
-size="2" face="Courier New">remove_bounds</font> provides a means
-of determining the underlying type of the array. For example <code>remove_bounds&lt;int[4][5]&gt;::type</code>
-would evaluate to the type <code>int[5]</code>. This example also
-shows that the number of template parameters in a partial
-specialisation 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>
-
-<h4>Optimised copy</h4>
-
-<p>As an example of how the type traits classes can be used,
-consider the standard library algorithm copy:</p>
-
-<pre>template&lt;typename Iter1, typename Iter2&gt;
-Iter2 copy(Iter1 first, Iter1 last, Iter2 out);</pre>
-
-<p>Obviously, there's no problem writing a generic version of
-copy that works for all iterator types Iter1 and Iter2; however,
-there are some circumstances when the copy operation can best be
-performed by a call to <font size="2" face="Courier New">memcpy</font>.
-In order to implement copy in terms of <font size="2"
-face="Courier New">memcpy</font> all of the following conditions
-need to be met:</p>
-
-<ul>
-    <li>Both of the iterator types Iter1 and Iter2 must be
-        pointers.</li>
-    <li>Both Iter1 and Iter2 must point to the same type -
-        excluding <font size="2" face="Courier New">const</font>
-        and <font size="2" face="Courier New">volatile</font>-qualifiers.</li>
-    <li>The type pointed to by Iter1 must have a trivial
-        assignment operator.</li>
-</ul>
-
-<p>By trivial assignment operator we mean that the type is either
-a scalar type[3] or:</p>
-
-<ul>
-    <li>The type has no user defined assignment operator.</li>
-    <li>The type does not have any data members that are
-        references.</li>
-    <li>All base classes, and all data member objects must have
-        trivial assignment operators.</li>
-</ul>
-
-<p>If all these conditions are met then a type can be copied
-using <font size="2" face="Courier New">memcpy</font> rather than
-using a compiler generated assignment operator. The type-traits
-library provides a class <i>has_trivial_assign</i>, such that <code>has_trivial_assign&lt;T&gt;::value</code>
-is true only if T has a trivial assignment operator. This class
-&quot;just works&quot; 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 <i>has_trivial_assign</i>
-gives the wrong answer, it will give the &quot;safe&quot; wrong
-answer - that trivial assignment is not allowable.</p>
-
-<p>The code for an optimised version of copy that uses <font
-size="2" face="Courier New">memcpy</font> where appropriate is
-given in listing 1. The code begins by defining a template class <i>copier</i>,
-that takes a single Boolean template parameter, and has a static
-template member function <font size="2" face="Courier New">do_copy</font>
-which performs the generic version of <font size="2">copy</font>
-(in other words the &quot;slow but safe version&quot;). Following
-that there is a specialisation for <i>copier&lt;true&gt;</i>:
-again this defines a static template member function <font
-size="2" face="Courier New">do_copy</font>, but this version uses
-memcpy to perform an &quot;optimised&quot; copy.</p>
-
-<p>In order to complete the implementation, what we need now is a
-version of copy, that calls <code>copier&lt;true&gt;::do_copy</code>
-if it is safe to use <font size="2" face="Courier New">memcpy</font>,
-and otherwise calls <code>copier&lt;false&gt;::do_copy</code> to
-do a &quot;generic&quot; copy. This is what the version in
-listing 1 does. To understand how the code works look at the code
-for <font size="2" face="Courier New">copy</font> and consider
-first the two typedefs <i>v1_t</i> and <i>v2_t</i>. These use <code>std::iterator_traits&lt;Iter1&gt;::value_type</code>
-to determine what type the two iterators point to, and then feed
-the result into another type-traits class <i>remove_cv</i> that
-removes the top-level const-volatile-qualifiers: this will allow
-copy to compare the two types without regard to const- or
-volatile-qualifiers. Next, <font size="2" face="Courier New">copy</font>
-declares an enumerated value <i>can_opt</i> that will become the
-template parameter to copier - declaring this here as a constant
-is really just a convenience - the value could be passed directly
-to class <font size="2" face="Courier New">copier</font>. The
-value of <i>can_opt</i> is computed by verifying that all of the
-following are true:</p>
-
-<ul>
-    <li>first that the two iterators point to the same type by
-        using a type-traits class <i>is_same</i>.</li>
-    <li>Then that both iterators are real pointers - using the
-        class <i>is_pointer</i> described above.</li>
-    <li>Finally that the pointed-to types have a trivial
-        assignment operator using <i>has_trivial_assign</i>.</li>
-</ul>
-
-<p>Finally we can use the value of <i>can_opt</i> as the template
-argument to copier - this version of copy will now adapt to
-whatever parameters are passed to it, if its possible to use <font
-size="2" face="Courier New">memcpy</font>, then it will do so,
-otherwise it will use a generic copy.</p>
-
-<h4>Was it worth it?</h4>
-
-<p>It has often been repeated in these columns that &quot;premature
-optimisation is the root of all evil&quot; [4]. So the question
-must be asked: was our optimisation premature? To put this in
-perspective the timings for our version of copy compared a
-conventional generic copy[5] are shown in table 1.</p>
-
-<p>Clearly the optimisation makes a difference in this case; but,
-to be fair, the timings are loaded to exclude cache miss effects
- without this accurate comparison between algorithms becomes
-difficult. However, perhaps we can add a couple of caveats to the
-premature optimisation rule:</p>
-
-<ul>
-    <li>If you use the right algorithm for the job in the first
-        place then optimisation will not be required; in some
-        cases, <font size="2" face="Courier New">memcpy</font> is
-        the right algorithm.</li>
-    <li>If a component is going to be reused in many places by
-        many people then optimisations may well be worthwhile
-        where they would not be so for a single case - in other
-        words, the likelihood that the optimisation will be
-        absolutely necessary somewhere, sometime is that much
-        higher. Just as importantly the perceived value of the
-        stock implementation will be higher: there is no point
-        standardising an algorithm if users reject it on the
-        grounds that there are better, more heavily optimised
-        versions available.</li>
-</ul>
-
-<h4>Table 1: Time taken to copy 1000 elements using copy&lt;const
-T*, T*&gt; (times in micro-seconds)</h4>
-
-<table border="1" cellpadding="7" cellspacing="1" width="529">
-    <tr>
-        <td valign="top" width="33%"><p align="center">Version</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">T</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">Time</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
-        <td valign="top" width="33%">char</td>
-        <td valign="top" width="33%">0.99</td>
-    </tr>
-    <tr>
-        <td valign="top" width="33%">Conventional copy</td>
-        <td valign="top" width="33%">char</td>
-        <td valign="top" width="33%">8.07</td>
-    </tr>
-    <tr>
-        <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
-        <td valign="top" width="33%">int</td>
-        <td valign="top" width="33%">2.52</td>
-    </tr>
-    <tr>
-        <td valign="top" width="33%">Conventional copy</td>
-        <td valign="top" width="33%">int</td>
-        <td valign="top" width="33%">8.02</td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h4>Pair of References</h4>
-
-<p>The optimised copy example shows how type traits may be used
-to perform optimisation decisions at compile-time. Another
-important usage of type traits is to allow code to compile that
-otherwise would not do so unless excessive partial specialization
-is used. This is possible by delegating partial specialization to
-the type traits classes. Our example for this form of usage is a
-pair that can hold references [6].</p>
-
-<p>First, let us examine the definition of &quot;std::pair&quot;,
-omitting the comparision operators, default constructor, and
-template copy constructor for simplicity:</p>
-
-<pre>template &lt;typename T1, typename T2&gt; 
-struct pair 
-{
-  typedef T1 first_type;
-  typedef T2 second_type;
-
-  T1 first;
-  T2 second;
-
-  pair(const T1 &amp; nfirst, const T2 &amp; nsecond)
-  :first(nfirst), second(nsecond) { }
-};</pre>
-
-<p>Now, this &quot;pair&quot; cannot hold references as it
-currently stands, because the constructor would require taking a
-reference to a reference, which is currently illegal [7]. Let us
-consider what the constructor's parameters would have to be in
-order to allow &quot;pair&quot; to hold non-reference types,
-references, and constant references:</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="638">
-    <tr>
-        <td valign="top" width="50%">Type of &quot;T1&quot;</td>
-        <td valign="top" width="50%">Type of parameter to
-        initializing constructor</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>T</pre>
-        </td>
-        <td valign="top" width="50%"><pre>const T &amp;</pre>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>T &amp;</pre>
-        </td>
-        <td valign="top" width="50%"><pre>T &amp;</pre>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>const T &amp;</pre>
-        </td>
-        <td valign="top" width="50%"><pre>const T &amp;</pre>
-        </td>
-    </tr>
-</table>
-
-<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 &quot;add_reference&quot;,
-which adds a reference to its type, unless it is already a
-reference.</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="580">
-    <tr>
-        <td valign="top" width="21%">Type of &quot;T1&quot;</td>
-        <td valign="top" width="27%">Type of &quot;const T1&quot;</td>
-        <td valign="top" width="53%">Type of &quot;add_reference&lt;const
-        T1&gt;::type&quot;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="21%"><pre>T</pre>
-        </td>
-        <td valign="top" width="27%"><pre>const T</pre>
-        </td>
-        <td valign="top" width="53%"><pre>const T &amp;</pre>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="21%"><pre>T &amp;</pre>
-        </td>
-        <td valign="top" width="27%"><pre>T &amp; [8]</pre>
-        </td>
-        <td valign="top" width="53%"><pre>T &amp;</pre>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="21%"><pre>const T &amp;</pre>
-        </td>
-        <td valign="top" width="27%"><pre>const T &amp;</pre>
-        </td>
-        <td valign="top" width="53%"><pre>const T &amp;</pre>
-        </td>
-    </tr>
-</table>
-
-<p>This allows us to build a primary template definition for
-&quot;pair&quot; that can contain non-reference types, reference
-types, and constant reference types:</p>
-
-<pre>template &lt;typename T1, typename T2&gt; 
-struct pair 
-{
-  typedef T1 first_type;
-  typedef T2 second_type;
-
-  T1 first;
-  T2 second;
-
-  pair(boost::add_reference&lt;const T1&gt;::type nfirst,
-       boost::add_reference&lt;const T2&gt;::type nsecond)
-  :first(nfirst), second(nsecond) { }
-};</pre>
-
-<p>Add back in the standard comparision operators, default
-constructor, and template copy constructor (which are all the
-same), and you have a std::pair that can hold reference types!</p>
-
-<p>This same extension <i>could</i> have been done using partial
-template specialization of &quot;pair&quot;, but to specialize
-&quot;pair&quot; in this way would require three partial
-specializations, plus the primary template. Type traits allows us
-to define a single primary template that adjusts itself auto-magically
-to any of these partial specializations, instead of a brute-force
-partial specialization approach. Using type traits in this
-fashion allows programmers to delegate partial specialization to
-the type traits classes, resulting in code that is easier to
-maintain and easier to understand.</p>
-
-<h4>Conclusion</h4>
-
-<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 are in the boost documentation,
-along with further examples using type traits. Templates have
-enabled C++ uses to take the advantage of the code reuse that
-generic programming brings; hopefully this article has shown that
-generic programming does not have to sink to the lowest common
-denominator, and that templates can be optimal as well as generic.</p>
-
-<h4>Acknowledgements</h4>
-
-<p>The authors would like to thank Beman Dawes and Howard Hinnant
-for their helpful comments when preparing this article.</p>
-
-<h4>References</h4>
-
-<ol>
-    <li>Nathan C. Myers, C++ Report, June 1995.</li>
-    <li>The type traits library is based upon contributions by
-        Steve Cleary, Beman Dawes, Howard Hinnant and John
-        Maddock: it can be found at www.boost.org.</li>
-    <li>A scalar type is an arithmetic type (i.e. a built-in
-        integer or floating point type), an enumeration type, a
-        pointer, a pointer to member, or a const- or volatile-qualified
-        version of one of these types.</li>
-    <li>This quote is from Donald Knuth, ACM Computing Surveys,
-        December 1974, pg 268.</li>
-    <li>The test code is available as part of the boost utility
-        library (see algo_opt_examples.cpp), the code was
-        compiled with gcc 2.95 with all optimisations turned on,
-        tests were conducted on a 400MHz Pentium II machine
-        running Microsoft Windows 98.</li>
-    <li>John Maddock and Howard Hinnant have submitted a &quot;compressed_pair&quot;
-        library to Boost, which uses a technique similar to the
-        one described here to hold references. Their pair also
-        uses type traits to determine if any of the types are
-        empty, and will derive instead of contain to conserve
-        space -- hence the name &quot;compressed&quot;.</li>
-    <li>This is actually an issue with the C++ Core Language
-        Working Group (issue #106), submitted by Bjarne
-        Stroustrup. The tentative resolution is to allow a &quot;reference
-        to a reference to T&quot; to mean the same thing as a
-        &quot;reference to T&quot;, but only in template
-        instantiation, in a method similar to multiple cv-qualifiers.</li>
-    <li>For those of you who are wondering why this shouldn't be
-        const-qualified, remember that references are always
-        implicitly constant (for example, you can't re-assign a
-        reference). Remember also that &quot;const T &amp;&quot;
-        is something completely different. For this reason, cv-qualifiers
-        on template type arguments that are references are
-        ignored.</li>
-</ol>
-
-<h2>Listing 1</h2>
-
-<pre>namespace detail{
-
-template &lt;bool b&gt;
-struct copier
-{
-   template&lt;typename I1, typename I2&gt;
-   static I2 do_copy(I1 first, 
-                     I1 last, I2 out);
-};
-
-template &lt;bool b&gt;
-template&lt;typename I1, typename I2&gt;
-I2 copier&lt;b&gt;::do_copy(I1 first, 
-                      I1 last, 
-                      I2 out)
-{
-   while(first != last)
-   {
-      *out = *first;
-      ++out;
-      ++first;
-   }
-   return out;
-}
-
-template &lt;&gt;
-struct copier&lt;true&gt;
-{
-   template&lt;typename I1, typename I2&gt;
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-}
-
-template&lt;typename I1, typename I2&gt;
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename 
-    boost::remove_cv&lt;
-     typename std::iterator_traits&lt;I1&gt;
-      ::value_type&gt;::type v1_t;
-
-   typedef typename 
-    boost::remove_cv&lt;
-     typename std::iterator_traits&lt;I2&gt;
-      ::value_type&gt;::type v2_t;
-
-   enum{ can_opt = 
-      boost::is_same&lt;v1_t, v2_t&gt;::value
-      &amp;&amp; boost::is_pointer&lt;I1&gt;::value
-      &amp;&amp; boost::is_pointer&lt;I2&gt;::value
-      &amp;&amp; boost::
-      has_trivial_assign&lt;v1_t&gt;::value 
-   };
-
-   return detail::copier&lt;can_opt&gt;::
-      do_copy(first, last, out);
-}</pre>
-
-<hr>
-
-<p><EFBFBD> Copyright John Maddock and Steve Cleary, 2000</p>
-</body>
-</html>
--- a/cxx_type_traits.htm
+++ b/cxx_type_traits.htm
@ -0,0 +1,19 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_typetraits/background.html">
+  </head>
+  <body>
+    Automatic redirection failed, please go to
+    <a href="../../doc/html/boost_typetraits/background.html">../../doc/html/boost_typetraits/background.html</a>
+    or view the online version at
+    <a href="http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_typetraits/background.html">http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_typetraits/background.html</a>
+      <P>Copyright&nbsp;John Maddock 2006</P>
+      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
+  </body>
+</html>
+
+
+
+
--- a/development/alignment_test.cpp
+++ b/development/alignment_test.cpp
@ -1,44 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/alignment_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-NESTED_DECL(alignment_of)
-
-int main(int argc, char* argv[])
-{
-   NESTED_TEST(alignment_of, int)
-   NESTED_TEST(alignment_of, int_constructible)
-
-   align_test(int);
-   align_test(char);
-   align_test(double);
-   align_test(int[4]);
-   align_test(int(*)(int));
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   align_test(char&);
-   align_test(char (&)(int));
-   align_test(char(&)[4]);
-#endif
-   align_test(int*);
-   //align_test(const int);
-   align_test(VB);
-   align_test(VD);
-   value_test(0, ::boost::alignment_of<void>::value);
-   
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-unsigned int expected_failures = 0;
-
--- a/development/arithmetic_traits_test.cpp
+++ b/development/arithmetic_traits_test.cpp
@ -1,197 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/arithmetic_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-NESTED_DECL(is_void)
-NESTED_DECL(is_integral)
-NESTED_DECL(is_float)
-NESTED_DECL(is_arithmetic)
-NESTED_DECL(is_fundamental)
-
-int main(int argc, char* argv[])
-{
-   NESTED_TEST(is_void, void)
-   NESTED_TEST(is_void, int)
-   NESTED_TEST(is_integral, int)
-   NESTED_TEST(is_integral, float)
-   NESTED_TEST(is_float, void)
-   NESTED_TEST(is_float, double)
-   NESTED_TEST(is_arithmetic, void)
-   NESTED_TEST(is_arithmetic, int)
-   NESTED_TEST(is_fundamental, UDT)
-   NESTED_TEST(is_fundamental, int)
-
-   value_test(true, boost::is_void<void>::value)
-   value_test(true, boost::is_void<const void>::value)
-   value_test(true, boost::is_void<volatile void>::value)
-   value_test(true, boost::is_void<const volatile void>::value)
-   value_test(false, boost::is_void<int>::value)
-
-   value_test(false, boost::is_integral<UDT>::value)
-   value_test(false, boost::is_integral<void>::value)
-   value_test(true, boost::is_integral<bool>::value)
-   value_test(true, boost::is_integral<char>::value)
-   value_test(true, boost::is_integral<signed char>::value)
-   value_test(true, boost::is_integral<unsigned char>::value)
-   value_test(true, boost::is_integral<wchar_t>::value)
-   value_test(true, boost::is_integral<short>::value)
-   value_test(true, boost::is_integral<unsigned short>::value)
-   value_test(true, boost::is_integral<int>::value)
-   value_test(true, boost::is_integral<unsigned int>::value)
-   value_test(true, boost::is_integral<long>::value)
-   value_test(true, boost::is_integral<unsigned long>::value)
-   value_test(false, boost::is_integral<float>::value)
-   value_test(false, boost::is_integral<double>::value)
-   value_test(false, boost::is_integral<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_integral<long long>::value)
-   value_test(true, boost::is_integral<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_integral<__int64>::value)
-   value_test(true, boost::is_integral<unsigned __int64>::value)
-   #endif
-   //const qualified ints:
-   value_test(true, boost::is_integral<const bool>::value)
-   value_test(true, boost::is_integral<const char>::value)
-   value_test(true, boost::is_integral<const signed char>::value)
-   value_test(true, boost::is_integral<const unsigned char>::value)
-   value_test(true, boost::is_integral<const wchar_t>::value)
-   value_test(true, boost::is_integral<const short>::value)
-   value_test(true, boost::is_integral<const unsigned short>::value)
-   value_test(true, boost::is_integral<const int>::value)
-   value_test(true, boost::is_integral<const unsigned int>::value)
-   value_test(true, boost::is_integral<const long>::value)
-   value_test(true, boost::is_integral<const unsigned long>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_integral<const long long>::value)
-   value_test(true, boost::is_integral<const unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_integral<const __int64>::value)
-   value_test(true, boost::is_integral<const unsigned __int64>::value)
-   #endif
-   // volatile qualified ints:
-   value_test(true, boost::is_integral<volatile bool>::value)
-   value_test(true, boost::is_integral<volatile char>::value)
-   value_test(true, boost::is_integral<volatile signed char>::value)
-   value_test(true, boost::is_integral<volatile unsigned char>::value)
-   value_test(true, boost::is_integral<volatile wchar_t>::value)
-   value_test(true, boost::is_integral<volatile short>::value)
-   value_test(true, boost::is_integral<volatile unsigned short>::value)
-   value_test(true, boost::is_integral<volatile int>::value)
-   value_test(true, boost::is_integral<volatile unsigned int>::value)
-   value_test(true, boost::is_integral<volatile long>::value)
-   value_test(true, boost::is_integral<volatile unsigned long>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_integral<volatile long long>::value)
-   value_test(true, boost::is_integral<volatile unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_integral<volatile __int64>::value)
-   value_test(true, boost::is_integral<volatile unsigned __int64>::value)
-   #endif
-   //const qualified ints:
-   value_test(true, boost::is_integral<const volatile bool>::value)
-   value_test(true, boost::is_integral<const volatile char>::value)
-   value_test(true, boost::is_integral<const volatile signed char>::value)
-   value_test(true, boost::is_integral<const volatile unsigned char>::value)
-   value_test(true, boost::is_integral<const volatile wchar_t>::value)
-   value_test(true, boost::is_integral<const volatile short>::value)
-   value_test(true, boost::is_integral<const volatile unsigned short>::value)
-   value_test(true, boost::is_integral<const volatile int>::value)
-   value_test(true, boost::is_integral<const volatile unsigned int>::value)
-   value_test(true, boost::is_integral<const volatile long>::value)
-   value_test(true, boost::is_integral<const volatile unsigned long>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_integral<const volatile long long>::value)
-   value_test(true, boost::is_integral<const volatile unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_integral<const volatile __int64>::value)
-   value_test(true, boost::is_integral<const volatile unsigned __int64>::value)
-   #endif
-   value_test(true, boost::is_float<const volatile float>::value)
-   value_test(true, boost::is_float<const volatile double>::value)
-   value_test(true, boost::is_float<const volatile long double>::value)
-   value_test(true, boost::is_float<volatile float>::value)
-   value_test(true, boost::is_float<volatile double>::value)
-   value_test(true, boost::is_float<volatile long double>::value)
-   value_test(true, boost::is_float<const float>::value)
-   value_test(true, boost::is_float<const double>::value)
-   value_test(true, boost::is_float<const long double>::value)
-   value_test(true, boost::is_float<float>::value)
-   value_test(true, boost::is_float<double>::value)
-   value_test(true, boost::is_float<long double>::value)
-   value_test(false, boost::is_float<int>::value)
-   value_test(false, boost::is_float<void>::value)
-   value_test(false, boost::is_float<UDT>::value)
-
-
-   value_test(false, boost::is_arithmetic<UDT>::value)
-   value_test(false, boost::is_arithmetic<void>::value)
-   value_test(true, boost::is_arithmetic<bool>::value)
-   value_test(true, boost::is_arithmetic<char>::value)
-   value_test(true, boost::is_arithmetic<signed char>::value)
-   value_test(true, boost::is_arithmetic<unsigned char>::value)
-   value_test(true, boost::is_arithmetic<wchar_t>::value)
-   value_test(true, boost::is_arithmetic<short>::value)
-   value_test(true, boost::is_arithmetic<unsigned short>::value)
-   value_test(true, boost::is_arithmetic<int>::value)
-   value_test(true, boost::is_arithmetic<unsigned int>::value)
-   value_test(true, boost::is_arithmetic<long>::value)
-   value_test(true, boost::is_arithmetic<unsigned long>::value)
-   value_test(true, boost::is_arithmetic<float>::value)
-   value_test(true, boost::is_arithmetic<double>::value)
-   value_test(true, boost::is_arithmetic<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_arithmetic<long long>::value)
-   value_test(true, boost::is_arithmetic<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_arithmetic<__int64>::value)
-   value_test(true, boost::is_arithmetic<unsigned __int64>::value)
-   #endif
-
-   value_test(false, boost::is_fundamental<UDT>::value)
-   value_test(true, boost::is_fundamental<void>::value)
-   value_test(true, boost::is_fundamental<bool>::value)
-   value_test(true, boost::is_fundamental<char>::value)
-   value_test(true, boost::is_fundamental<signed char>::value)
-   value_test(true, boost::is_fundamental<unsigned char>::value)
-   value_test(true, boost::is_fundamental<wchar_t>::value)
-   value_test(true, boost::is_fundamental<short>::value)
-   value_test(true, boost::is_fundamental<unsigned short>::value)
-   value_test(true, boost::is_fundamental<int>::value)
-   value_test(true, boost::is_fundamental<unsigned int>::value)
-   value_test(true, boost::is_fundamental<long>::value)
-   value_test(true, boost::is_fundamental<unsigned long>::value)
-   value_test(true, boost::is_fundamental<float>::value)
-   value_test(true, boost::is_fundamental<double>::value)
-   value_test(true, boost::is_fundamental<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, boost::is_fundamental<long long>::value)
-   value_test(true, boost::is_fundamental<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, boost::is_fundamental<__int64>::value)
-   value_test(true, boost::is_fundamental<unsigned __int64>::value)
-   #endif
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-unsigned int expected_failures = 0;
-
--- a/development/composite_traits_test.cpp
+++ b/development/composite_traits_test.cpp
@ -1,116 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/composite_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-NESTED_DECL(is_array)
-NESTED_DECL(is_pointer)
-NESTED_DECL(is_reference)
-
-int main(int argc, char* argv[])
-{
-   NESTED_TEST(is_array, int)
-   NESTED_TEST(is_array, int[2])
-   NESTED_TEST(is_array, int[3][4])
-   NESTED_TEST(is_array, int const [5])
-   NESTED_TEST(is_array, int(&)[2])
-   NESTED_TEST(is_array, int (*)(double))
-   NESTED_TEST(is_pointer, int)
-   NESTED_TEST(is_pointer, int*)
-   NESTED_TEST(is_reference, int)
-   NESTED_TEST(is_reference, int&)
-
-   value_test(false, boost::is_array<int>::value)
-   value_test(false, boost::is_array<int*>::value)
-   value_test(false, boost::is_array<const int*>::value)
-   value_test(false, boost::is_array<const volatile int*>::value)
-   value_test(false, boost::is_array<int*const>::value)
-   value_test(false, boost::is_array<const int*volatile>::value)
-   value_test(false, boost::is_array<const volatile int*const>::value)
-   value_test(true, boost::is_array<int[2]>::value)
-   value_test(true, boost::is_array<const int[2]>::value)
-   value_test(true, boost::is_array<const volatile int[2]>::value)
-   value_test(true, boost::is_array<int[2][3]>::value)
-   value_test(true, boost::is_array<UDT[2]>::value)
-   value_test(false, boost::is_array<int(&)[2]>::value)
-   value_test(false, boost::is_array<f1>::value)
-   value_test(false, boost::is_array<void>::value)
-
-   value_test(false, boost::is_pointer<int>::value)
-   value_test(false, boost::is_pointer<int&>::value)
-   value_test(true, boost::is_pointer<int*>::value)
-   value_test(true, boost::is_pointer<const int*>::value)
-   value_test(true, boost::is_pointer<volatile int*>::value)
-   value_test(true, boost::is_pointer<non_pointer*>::value)
-   // these were false in previous versions (JM 20 Dec 2000):
-   value_test(true, boost::is_pointer<int*const>::value)
-   value_test(true, boost::is_pointer<int*volatile>::value)
-   value_test(true, boost::is_pointer<int*const volatile>::value)
-   // JM 02 Oct 2000:
-   value_test(false, boost::is_pointer<non_pointer>::value)
-   value_test(false, boost::is_pointer<int*&>::value)
-   value_test(false, boost::is_pointer<int(&)[2]>::value)
-   value_test(false, boost::is_pointer<int[2]>::value)
-   value_test(false, boost::is_pointer<char[sizeof(void*)]>::value)
-   value_test(false, boost::is_pointer<void>::value)
-
-   value_test(true, boost::is_pointer<f1>::value)
-   value_test(true, boost::is_pointer<f2>::value)
-   value_test(true, boost::is_pointer<f3>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, boost::is_pointer<mf1>::value)
-   value_test(false, boost::is_pointer<mf2>::value)
-   value_test(false, boost::is_pointer<mf3>::value)
-   value_test(false, boost::is_pointer<mf4>::value)
-
-   value_test(false, boost::is_reference<bool>::value)
-   value_test(true, boost::is_reference<int&>::value)
-   value_test(true, boost::is_reference<const int&>::value)
-   value_test(true, boost::is_reference<volatile int &>::value)
-   value_test(true, boost::is_reference<const volatile int &>::value)
-   value_test(true, boost::is_reference<r_type>::value)
-   value_test(true, boost::is_reference<cr_type>::value)
-   value_test(true, boost::is_reference<const UDT&>::value)
-   value_test(false, boost::is_reference<void>::value)
-
-   value_test(false, boost::is_member_pointer<f1>::value)
-   value_test(false, boost::is_member_pointer<f2>::value)
-   value_test(false, boost::is_member_pointer<f3>::value)
-   value_test(false, boost::is_member_pointer<void*>::value)
-   value_test(true, boost::is_member_pointer<mf1>::value)
-   value_test(true, boost::is_member_pointer<mf2>::value)
-   value_test(true, boost::is_member_pointer<mf3>::value)
-   value_test(true, boost::is_member_pointer<mf4>::value)
-   value_test(false, boost::is_member_pointer<void>::value)
-
-   value_test(false, boost::is_enum<int>::value)
-   value_test(true, boost::is_enum<enum_UDT>::value)
-   value_test(false, boost::is_enum<int_convertible>::value)
-   value_test(false, boost::is_enum<int&>::value)
-   value_test(false, boost::is_enum<void>::value)
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef __BORLANDC__
-unsigned int expected_failures = 2;
-#elif defined(__GNUC__)
-unsigned int expected_failures = 1; // can't handle cv-qualified references
-#elif defined(BOOST_MSVC)
-unsigned int expected_failures = 1;
-#else
-unsigned int expected_failures = 0;
-#endif
-
-
--- a/development/copy_example.cpp
+++ b/development/copy_example.cpp
@ -1,240 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::copy - optimised for trivial copy (cf std::copy)
- *
- */
-
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include <iterator>
-#include <memory>
-
-#include <boost/timer.hpp>
-#include <boost/type_traits.hpp>
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-namespace opt{
-
-//
-// opt::copy
-// same semantics as std::copy
-// calls memcpy where appropiate.
-//
-
-namespace detail{
-
-template<typename I1, typename I2>
-I2 copy_imp(I1 first, I1 last, I2 out)
-{
-   while(first != last)
-   {
-      *out = *first;
-      ++out;
-      ++first;
-   }
-   return out;
-}
-
-template <bool b>
-struct copier
-{
-   template<typename I1, typename I2>
-   static I2 do_copy(I1 first, I1 last, I2 out)
-   { return copy_imp(first, last, out); }
-};
-
-template <>
-struct copier<true>
-{
-   template<typename I1, typename I2>
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-
-}
-
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-
-template<typename I1, typename I2>
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
-   typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
-   return detail::copier<
-      ::boost::type_traits::ice_and<
-         ::boost::is_same<v1_t, v2_t>::value,
-         ::boost::is_pointer<I1>::value,
-         ::boost::is_pointer<I2>::value,
-         ::boost::has_trivial_assign<v1_t>::value
-      >::value>::do_copy(first, last, out);
-}
-
-#else // BOOST_NO_STD_ITERATOR_TRAITS
-
-//
-// If there is no standard iterator_traits then we have to
-// use overloading rather than iterator_traits to detect
-// when we have T*'s to copy.  Note that we cannot overload
-// copy directly as that will cause some standard conforming
-// code to fail to build:
-
-namespace detail{
-
-template<typename I1, typename I2>
-inline I2 copy_(const I1& first, const I1& last, const I2& out)
-{
-   return detail::copier<false>::do_copy(first, last, out);
-}
-
-template<typename T>
-inline T* copy_(const T* first, const T* last, T* out)
-{
-   return detail::copier< 
-      ::boost::has_trivial_assign<T>::value
-   >::do_copy(first, last, out);
-}
-
-} // namespace detail
-
-template<typename I1, typename I2>
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   return detail::copy_(first, last, out);
-}
-
-#endif // BOOST_NO_STD_ITERATOR_TRAITS
-
-};   // namespace opt
-
-//
-// define some global data:
-//
-const int array_size = 1000;
-int i_array_[array_size] = {0,};
-const int ci_array_[array_size] = {0,};
-char c_array_[array_size] = {0,};
-const char cc_array_[array_size] = { 0,};
-//
-// since arrays aren't iterators we define a set of pointer
-// aliases into the arrays (otherwise the compiler is entitled
-// to deduce the type passed to the template functions as
-// T (&)[N] rather than T*).
-int* i_array = i_array_;
-const int* ci_array = ci_array_;
-char* c_array = c_array_;
-const char* cc_array = cc_array_;
-
-const int iter_count = 1000000;
-
-int main()
-{
-   boost::timer t;
-   double result;
-   int i;
-   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
-   cout << "testing copy...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-   
-   // cache load:
-   opt::copy(ci_array, ci_array + array_size, i_array);
-
-   // time optimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const int*, int*>: " << result << endl;
-
-   // cache load:
-   std::copy(ci_array, ci_array + array_size, i_array);
-
-   // time standard version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const int*, int*>: " << result << endl;
-
-   // cache load:
-   opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
-
-   // time unoptimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-   // cache load:
-   opt::copy(cc_array, cc_array + array_size, c_array);
-
-   // time optimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const char*, char*>: " << result << endl;
-
-   // cache load:
-   std::copy(cc_array, cc_array + array_size, c_array);
-
-   // time standard version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const char*, char*>: " << result << endl;
-
-   // cache load:
-   opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
-
-   // time unoptimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-   return 0;
-}
-
-
-
-
-
-
--- a/development/cs-linux.html
+++ b/development/cs-linux.html
@ -1,113 +0,0 @@
-<html>
-<head>
-<title>
-Compiler Status: linux
-</title>
-</head>
-<body bgcolor="#ffffff" text="#000000">
-<h1><img border border="0" src="../c++boost.gif" width="277" height="86"></h1>
-<h1>Compiler Status: linux</h1>
-
-<p><b>Run Date:</b> 07 Jan 2001 22:21 GMT</p>
-<p><b>System Configuration:</b> Linux 2.2.13</p>
-<p>
-<table border="1" cellspacing="0" cellpadding="5">
-<tr>
-<td>Program</td>
-<td>Test<br>Type</td>
-<td>GNU<br>GCC<br>2.95.2</td>
-<td>GNU<br>GCC<br>2.95.2<br>STLport<br>4.0</td>
-<td>Comeau C++<br>4.2.44 beta3<br>STLport<br>4.0</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/alignment_test.cpp">libs/type_traits/alignment_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td><font color="#FF0000">Fail</font></td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/arithmetic_traits_test.cpp">libs/type_traits/arithmetic_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/composite_traits_test.cpp">libs/type_traits/composite_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/cv_traits_test.cpp">libs/type_traits/cv_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/is_convertible_test.cpp">libs/type_traits/is_convertible_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/is_same_test.cpp">libs/type_traits/is_same_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/object_type_traits_test.cpp">libs/type_traits/object_type_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td><font color="#FF0000">Fail</font></td>
-<td><font color="#FF0000">Fail</font></td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/transform_traits_test.cpp">libs/type_traits/transform_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/trivial_destructor_example.cpp">libs/type_traits/trivial_destructor_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/copy_example.cpp">libs/type_traits/copy_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/fill_example.cpp">libs/type_traits/fill_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/iter_swap_example.cpp">libs/type_traits/iter_swap_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-</table></p>
-<p>
-Notes: A hand-crafted &lt;limits&gt; Standard header has been
-applied to all configurations.
-The tests were run on a GNU libc 2.2 system which has improved
-wide character support compared to previous versions.</p>
-</body>
-</html>
--- a/development/cs-win32.html
+++ b/development/cs-win32.html
@ -1,162 +0,0 @@
-<html>
-<head>
-<title>
-Compiler Status: win32
-</title>
-</head>
-<body bgcolor="#ffffff" text="#000000">
-<h1><img border border="0" src="../c++boost.gif" width="277" height="86"></h1>
-<h1>Compiler Status: win32</h1>
-
-<p><b>Run Date:</b> 03 Feb 2001 11:25 GMT</p>
-<p><b>System Configuration:</b> Microsoft Windows 32bit</p>
-<p>
-<table border="1" cellspacing="0" cellpadding="5">
-<tr>
-<td>Program</td>
-<td>Test<br>Type</td>
-<td>cygwin<br>GCC 2.95.2</td>
-<td>cygwin<br>GCC 2.95.2<br>+ SGI STL 3.3</td>
-<td>cygwin<br>GCC 2.95.2<br>+ STLPort 4</td>
-<td>Borland<br>5.5.1</td>
-<td>Borland<br>5.4</td>
-<td>Microsoft<br>VC++<br>6.0 SP4</td>
-<td>Microsoft<br>VC++<br>6.0 SP4<br>STLport<br>4.0</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/alignment_test.cpp">libs/type_traits/alignment_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/arithmetic_traits_test.cpp">libs/type_traits/arithmetic_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/composite_traits_test.cpp">libs/type_traits/composite_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/cv_traits_test.cpp">libs/type_traits/cv_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/is_convertible_test.cpp">libs/type_traits/is_convertible_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td><font color="#FF0000">Fail</font></td>
-<td><font color="#FF0000">Fail</font></td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/is_same_test.cpp">libs/type_traits/is_same_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/object_type_traits_test.cpp">libs/type_traits/object_type_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/transform_traits_test.cpp">libs/type_traits/transform_traits_test.cpp</a></td>
-<td>run</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td><font color="#FF0000">Fail</font></td>
-<td><font color="#FF0000">Fail</font></td>
-<td><font color="#FF0000">Fail</font></td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/trivial_destructor_example.cpp">libs/type_traits/trivial_destructor_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/copy_example.cpp">libs/type_traits/copy_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/fill_example.cpp">libs/type_traits/fill_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-</tr>
-<tr>
-<td><a href="../libs/type_traits/iter_swap_example.cpp">libs/type_traits/iter_swap_example.cpp</a></td>
-<td>compile</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td>Pass</td>
-<td><font color="#FF0000">Fail</font></td>
-<td><font color="#FF0000">Fail</font></td>
-</tr>
-</table></p>
-<p>
-</p>
-</body>
-</html>
--- a/development/cv_traits_test.cpp
+++ b/development/cv_traits_test.cpp
@ -1,50 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-NESTED_DECL(is_const)
-NESTED_DECL(is_volatile)
-
-int main(int argc, char* argv[])
-{
-   NESTED_TEST(is_const, int)
-   NESTED_TEST(is_const, const int)
-   NESTED_TEST(is_const, volatile int)
-   NESTED_TEST(is_volatile, int)
-   NESTED_TEST(is_volatile, const int)
-   NESTED_TEST(is_volatile, volatile int)
-
-   value_test(false, boost::is_const<void>::value)
-   value_test(true, boost::is_const<const void>::value)
-   value_test(false, boost::is_const<int>::value)
-   value_test(true, boost::is_const<const int>::value)
-   value_test(true, boost::is_const<const UDT>::value)
-   value_test(true, boost::is_const<const volatile UDT>::value)
-   value_test(false, boost::is_volatile<void>::value)
-   value_test(true, boost::is_volatile<volatile void>::value)
-   value_test(false, boost::is_volatile<int>::value)
-   value_test(true, boost::is_volatile<volatile int>::value)
-   value_test(true, boost::is_volatile<volatile UDT>::value)
-   value_test(true, boost::is_volatile<volatile UDT>::value)
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef BOOST_MSVC
-unsigned int expected_failures = 2;
-#else
-unsigned int expected_failures = 0;
-#endif
-
--- a/development/fill_example.cpp
+++ b/development/fill_example.cpp
@ -1,191 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::fill - optimised for trivial copy/small types (cf std::fill)
- *
- */
-
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include <iterator>
-#include <memory>
-
-#include <boost/timer.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/call_traits.hpp>
-
-#if defined(BOOST_NO_STDC_NAMESPACE) || (defined(std) && defined(__SGI_STL_PORT))
-namespace std{ using :: memset; }
-#endif
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-namespace opt{
-//
-// fill
-// same as std::fill, uses memset where appropriate, along with call_traits
-// to "optimise" parameter passing.
-//
-namespace detail{
-
-template <typename I, typename T>
-void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
-{
-   while(first != last)
-   {
-      *first = val;
-      ++first;
-   }
-}
-
-template <bool opt>
-struct filler
-{
-   template <typename I, typename T>
-   struct rebind
-   {
-      static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
-      { do_fill_<I,T>(first, last, val); }
-   };
-};
-
-template <>
-struct filler<true>
-{
-   template <typename I, typename T>
-   struct rebind
-   {
-      static void do_fill(I first, I last, T val)
-      {
-         std::memset(first, val, last-first);
-      }
-   };
-};
-
-}
-
-template <class I, class T>
-inline void fill(I first, I last, const T& val)
-{
-   typedef detail::filler<
-      ::boost::type_traits::ice_and<
-         ::boost::is_pointer<I>::value,
-         ::boost::is_arithmetic<T>::value,
-         (sizeof(T) == 1)
-      >::value> filler_t;
-   typedef typename filler_t:: template rebind<I,T> binder;
-   binder::do_fill(first, last, val);
-}
-
-};   // namespace opt
-
-//
-// define some global data:
-//
-const int array_size = 1000;
-int i_array_[array_size] = {0,};
-const int ci_array_[array_size] = {0,};
-char c_array_[array_size] = {0,};
-const char cc_array_[array_size] = { 0,};
-//
-// since arrays aren't iterators we define a set of pointer
-// aliases into the arrays (otherwise the compiler is entitled
-// to deduce the type passed to the template functions as
-// T (&)[N] rather than T*).
-int* i_array = i_array_;
-const int* ci_array = ci_array_;
-char* c_array = c_array_;
-const char* cc_array = cc_array_;
-
-const int iter_count = 1000000;
-
-int main()
-{
-   boost::timer t;
-   double result;
-   int i;
-   //
-   // test destroy_array,
-   // compare destruction time of an array of ints
-   // with unoptimised form.
-   //
-   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
-
-   cout << "testing fill(char)...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-
-   // cache load:
-   opt::fill(c_array, c_array + array_size, (char)3);
-
-   // time optimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<char*, char>: " << result << endl;
-
-   // cache load:
-   std::fill(c_array, c_array + array_size, (char)3);
-
-   // time standard version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<char*, char>: " << result << endl << endl;
-
-   cout << "testing fill(int)...\n"
-   "[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
-
-   // cache load:
-   opt::fill(i_array, i_array + array_size, 3);
-
-   // timer optimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<int*, int>: " << result << endl;
-
-   // cache load:
-   std::fill(i_array, i_array + array_size, 3);
-
-   // time standard version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<int*, int>: " << result << endl << endl;
-
-   return 0;
-}
-
-
-
-
-
--- a/development/include/boost/call_traits.hpp
+++ b/development/include/boost/call_traits.hpp
@ -1,23 +0,0 @@
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_CALL_TRAITS_HPP
-#define BOOST_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_call_traits.hpp>
-#else
-#include <boost/detail/call_traits.hpp>
-#endif
-
-#endif // BOOST_CALL_TRAITS_HPP
--- a/development/include/boost/config.hpp
+++ b/development/include/boost/config.hpp
@ -1,427 +0,0 @@
-//  Boost config.hpp configuration header file  ------------------------------//
-
-//  (C) Copyright Boost.org 1999. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version.
-
-//  Boost config.hpp policy and rationale documentation has been moved to
-//  http://www.boost.org/libs/config
-
-//  Revision History (excluding minor changes for specific compilers)
-//   31 Dec 00  BOOST_NO_CV_SPECIALIZATIONS
-//              BOOST_NO_CV_VOID_SPECIALIZATIONS (John Maddock)
-//   17 Nov 00  BOOST_NO_AUTO_PTR (John Maddock)
-//    4 Oct 00  BOOST_NO_STD_MIN_MAX (Jeremy Siek)
-//   29 Sep 00  BOOST_NO_INTEGRAL_INT64_T (Jens Maurer)
-//   25 Sep 00  BOOST_NO_STD_ALLOCATOR (Jeremy Siek)
-//   18 SEP 00  BOOST_NO_SLIST, BOOST_NO_HASH, 
-//              BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
-//              BOOST_NO_LIMITS (Jeremy Siek)
-//    1 Sep 00  BOOST_NO_PRIVATE_IN_AGGREGATE added. (Mark Rodgers)
-//   23 Jul 00  Fixed spelling of BOOST_NO_INCLASS_MEMBER_INITIALIZATION in
-//              comment (Dave Abrahams). 
-//   10 Jul 00  BOOST_NO_POINTER_TO_MEMBER_CONST added (Mark Rodgers)
-//   26 Jun 00  BOOST_NO_STD_ITERATOR, BOOST_MSVC_STD_ITERATOR,
-//              BOOST_NO_STD_ITERATOR_TRAITS, BOOST_NO_USING_TEMPLATE,
-//              added (Jeremy Siek)
-//   20 Jun 00  BOOST_MSVC added (Aleksey Gurtovoy)
-//   14 Jun 00  BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS (Jens M.)
-//   22 Mar 00  BOOST_MSVC6_MEMBER_TEMPLATES added (Dave Abrahams)
-//   18 Feb 00  BOOST_NO_INCLASS_MEMBER_INITIALIZATION added (Jens Maurer)
-//   26 Jan 00  Borland compiler support added (John Maddock)
-//   26 Jan 00  Sun compiler support added (J<>rg Schaible)
-//   30 Dec 99  BOOST_NMEMBER_TEMPLATES compatibility moved here from
-//              smart_ptr.hpp. (Dave Abrahams)
-//   15 Nov 99  BOOST_NO_OPERATORS_IN_NAMESPACE,
-//              BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION added (Beman Dawes)
-//   11 Oct 99  BOOST_NO_STDC_NAMESPACE refined; <cstddef> supplied
-//   29 Sep 99  BOOST_NO_STDC_NAMESPACE added (Ed Brey)
-//   24 Sep 99  BOOST_DECL added (Ed Brey)
-//   10 Aug 99  Endedness flags added, GNU CC support added
-//   22 Jul 99  Initial version
- 
-
-#ifndef BOOST_CONFIG_HPP
-#define BOOST_CONFIG_HPP
-
-//  Conformance Flag Macros  -------------------------------------------------//
-//
-//  Conformance flag macros should identify the absence of C++ Standard 
-//  conformance rather than its presence.  This ensures that standard conforming
-//  compilers do not require a lot of configuration flag macros.  It places the
-//  burden where it should be, on non-conforming compilers.  In the future,
-//  hopefully, less rather than more conformance flags will have to be defined.
-
-//  BOOST_NO_CV_SPECIALIZATIONS: if template specialisations for cv-qualified types
-//  conflict with a specialistaion for unqualififed type.
-
-//  BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specialisations for cv-void types
-//  conflict with a specialistaion for void.
-
-//  BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS: Template value
-//  parameters cannot have a dependent type, for example
-//  "template<class T, typename T::type value> class X { ... };"
-
-//  BOOST_NO_INCLASS_MEMBER_INITIALIZATION: Compiler violates std::9.4.2/4. 
-
-//  BOOST_NO_INT64_T: <boost/cstdint.hpp> does not support 64-bit integer
-//  types.  (Set by <boost/cstdint.hpp> rather than <boost/config.hpp>).
-
-//  BOOST_NO_INTEGRAL_INT64_T: int64_t as defined by <boost/cstdint.hpp> is
-//  not an integral type.
-
-//  BOOST_NO_MEMBER_TEMPLATES: Member template functions not fully supported.
-//  Also see BOOST_MSVC6_MEMBER_TEMPLATES in the Compiler Control section below.
-
-//  BOOST_NO_MEMBER_TEMPLATE_FRIENDS: Member template friend syntax
-//  ("template<class P> friend class frd;") described in the C++ Standard,
-//  14.5.3, not supported.
-
-//  BOOST_NO_OPERATORS_IN_NAMESPACE: Compiler requires inherited operator
-//  friend functions to be defined at namespace scope, then using'ed to boost.
-//  Probably GCC specific.  See boost/operators.hpp for example.
-
-//  BOOST_NO_POINTER_TO_MEMBER_CONST: The compiler does not correctly handle
-//  pointers to const member functions, preventing use of these in overloaded 
-//  function templates.  See boost/functional.hpp for example.
-
-//  BOOST_NO_PRIVATE_IN_AGGREGATE: The compiler misreads 8.5.1, treating classes
-//  as non-aggregate if they contain private or protected member functions. 
-
-//  BOOST_NO_STD_ITERATOR: The C++ implementation fails to provide the
-//  std::iterator class.
-
-//  BOOST_NO_STD_ITERATOR_TRAITS: The compiler does not provide a standard
-//  compliant implementation of std::iterator_traits. Note that
-//  the compiler may still have a non-standard implementation.
-
-//  BOOST_NO_STDC_NAMESPACE: The contents of C++ standard headers for C library
-//  functions (the <c...> headers) have not been placed in namespace std.
-//  Because the use of std::size_t is so common, a specific workaround for
-//  <cstddef> (and thus std::size_t) is provided in this header (see below).
-//  For other <c...> headers, a workaround must be provided in the boost header:
-//
-//    #include <cstdlib>  // for abs
-//    #ifdef BOOST_NO_STDC_NAMESPACE
-//      namespace std { using ::abs; }
-//    #endif
-
-//  BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION. Class template partial
-//  specialization (14.5.4 [temp.class.spec]) not supported.
-
-//  BOOST_NO_USING_TEMPLATE: The compiler will not accept a using declaration
-//  that imports a template from the global namespace into a named namespace.
-//  Probably Borland specific.
-
-//  BOOST_NO_AUTO_PTR: If the compiler / library supplies non-standard or broken
-//  std::auto_ptr.
-
-//  Compiler Control or Information Macros  ----------------------------------//
-//
-//  Compilers often supply features outside of the C++ Standard which need to be
-//  controlled or detected. As usual, reasonable default behavior should occur
-//  if any of these macros are not defined.
-
-//  BOOST_DECL:  Certain compilers for Microsoft operating systems require
-//  non-standard class and function decoration if dynamic load library linking
-//  is desired.  BOOST_DECL supplies that decoration, defaulting to a nul string
-//  so that it is harmless when not required.  Boost does not encourage the use
-//  of BOOST_DECL - it is non-standard and to be avoided if practical to do so.
-
-//  BOOST_DECL_EXPORTS:  User defined, BOOST_DECL_EXPORTS causes BOOST_DECL to
-//  be defined as __declspec(dllexport) rather than __declspec(dllimport).
-
-//  BOOST_MSVC6_MEMBER_TEMPLATES:  Microsoft Visual C++ 6.0 has enough member
-//  template idiosyncrasies (being polite) that BOOST_NO_MEMBER_TEMPLATES is
-//  defined for this compiler. BOOST_MSVC6_MEMBER_TEMPLATES is defined to allow
-//  compiler specific workarounds.
-
-//  BOOST_MSVC: defined as _MSC_VER for the Microsoft compiler only. In general,
-//  boost headers should test for a specific conformance flag macro (for
-//  example, BOOST_NO_MEMBER_TEMPLATE_FRIENDS) rather than a specific compiler.
-//  VC++ is a special case, however, since many libraries try to support it yet
-//  it has so many conformance issues that sometimes it is just easier to test
-//  for it directly. On the other hand, the obvious way to do this doesn't work,
-//  as many non-Microsoft compilers define _MSC_VER.  Thus BOOST_MSVC.
-
-//  BOOST_MSVC_STD_ITERATOR: Microsoft's broken version of std::iterator
-//  is being used. 
-
-//  BOOST_SYSTEM_HAS_STDINT_H: There are no 1998 C++ Standard headers <stdint.h> 
-//  or <cstdint>, although the 1999 C Standard does include <stdint.h>. 
-//  If <stdint.h> is present, <boost/stdint.h> can make good use of it,
-//  so a flag is supplied (signalling presence; thus the default is not
-//  present, conforming to the current C++ standard).
-
-//  BOOST_NO_SLIST: The C++ implementation does not provide the slist class.
-
-//  BOOST_NO_HASH: The C++ implementation does not provide the hash_set
-//  or hash_map classes.
-
-//  BOOST_STD_EXTENSION_NAMESPACE: The name of the namespace in which the slist,
-//  hash_set and/or hash_map templates are defined in this implementation (if any).
-
-//  BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS: The standard library does not provide
-//  templated iterator constructors for its containers.
-
-//  BOOST_NO_LIMITS: The C++ implementation does not provide the <limits> header.
-
-//  BOOST_NO_INTRINSIC_WCHAR_T: The C++ implementation does not provide wchar_t,
-//  or it is really a synonym for another integral type. Use this symbol to
-//  decide whether it is appropriate to explicitly specialize a template on
-//  wchar_t if there is already a specialization for other integer types.
-
-//  BOOST_NO_STD_ALLOCATOR: The C++ standard library does not provide
-//  a standards conforming std::allocator.
-
-//  BOOST_NO_STD_MIN_MAX: The C++ standard library does not provide
-//  the min() and max() template functions that should be in <algorithm>.
-
-//  Compilers are listed in alphabetic order (except VC++ last - see below)---//
-
-//  GNU CC (also known as GCC and G++)  --------------------------------------//
-
-# if defined __GNUC__
-#   if __GNUC__ == 2 && __GNUC_MINOR__ == 91
-       // egcs 1.1 won't parse smart_ptr.hpp without this:
-#      define BOOST_NO_AUTO_PTR
-#   endif
-#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
-#     include <iterator>  // not sure this is the right way to do this -JGS
-#     if !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS
-#       define BOOST_NO_STD_ITERATOR
-#       define BOOST_NO_LIMITS
-#     endif
-#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-#     define BOOST_NO_OPERATORS_IN_NAMESPACE
-#   endif
-#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
-#     define BOOST_NO_MEMBER_TEMPLATES
-#   endif
-
-//  Kai C++ ------------------------------------------------------------------//
-
-#elif defined __KCC
-#   define BOOST_NO_SLIST
-#   define BOOST_NO_HASH
-
-//  Greenhills C++ -----------------------------------------------------------//
-
-#elif defined __ghs
-#   define BOOST_NO_SLIST
-#   define BOOST_NO_HASH
-
-//  Borland ------------------------------------------------------------------//
-
-#elif defined __BORLANDC__
-#   define BOOST_NO_SLIST
-#   define BOOST_NO_HASH
-#   if __BORLANDC__ <= 0x0551
-#     define BOOST_NO_INTEGRAL_INT64_T
-#     define BOOST_NO_PRIVATE_IN_AGGREGATE
-#   endif
-#   if __BORLANDC__ <= 0x0550
-// Borland C++ Builder 4 and 5:
-#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-#     define BOOST_NO_USING_TEMPLATE
-#     if __BORLANDC__ == 0x0550
-// Borland C++ Builder 5, command-line compiler 5.5:
-#       define BOOST_NO_OPERATORS_IN_NAMESPACE
-#     endif
-#   endif
-#   if defined BOOST_DECL_EXPORTS
-#     define BOOST_DECL __declspec(dllexport)
-#   else
-#     define BOOST_DECL __declspec(dllimport)
-#   endif
-#   define BOOST_NO_CV_SPECIALIZATIONS
-#   define BOOST_NO_CV_VOID_SPECIALIZATIONS
-
-//  Intel  -------------------------------------------------------------------//
-
-# elif defined __ICL
-#   include <iterator>  // not sure this is the right way to do this -JGS
-#   if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
-        // a perfectly good implementation of std::iterator is supplied
-#   elif defined(__SGI_STL_ITERATOR)
-#     define BOOST_NO_STD_ITERATOR // No std::iterator in this case
-#   else // assume using dinkumware's STL that comes with VC++ 6.0
-#     define BOOST_MSVC_STD_ITERATOR
-#     define BOOST_NO_STD_ITERATOR_TRAITS
-#     define BOOST_NO_STDC_NAMESPACE
-#     define BOOST_NO_SLIST
-#     define BOOST_NO_HASH
-#     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
-#     define BOOST_NO_STD_ALLOCATOR
-#     define BOOST_NO_STD_MIN_MAX
-#   endif
-
-
-//  Metrowerks CodeWarrior  --------------------------------------------------//
-
-# elif defined  __MWERKS__
-#   if __MWERKS__ <= 0x4000
-#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-#   endif
-#   if __MWERKS__ <= 0x2301
-#     define BOOST_NO_POINTER_TO_MEMBER_CONST
-#   endif
-#   if __MWERKS__ >= 0x2300
-#     define BOOST_SYSTEM_HAS_STDINT_H
-#   endif
-#   if defined BOOST_DECL_EXPORTS
-#     define BOOST_DECL __declspec(dllexport)
-#   else
-#     define BOOST_DECL __declspec(dllimport)
-#   endif
-
-#   define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
-
-//  Sun Workshop Compiler C++ ------------------------------------------------//
-
-# elif defined  __SUNPRO_CC
-#    if __SUNPRO_CC <= 0x500
-#      define BOOST_NO_MEMBER_TEMPLATES
-#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#    endif
-
-//  Microsoft Visual C++ (excluding Intel/EDG front end)  --------------------//
-//
-//  Must remain the last #elif since some other vendors (Metrowerks, for
-//  example) also #define _MSC_VER
-
-# elif defined _MSC_VER
-#   define BOOST_MSVC _MSC_VER
-
-    // turn off the warnings before we #include anything
-#   pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info
-#   pragma warning( disable : 4503 ) // warning: decorated name length exceeded
-
-#   if _MSC_VER <= 1200  // 1200 == VC++ 6.0
-#     define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-#     define BOOST_NO_PRIVATE_IN_AGGREGATE
-
-#     define BOOST_NO_INTEGRAL_INT64_T
-#     define BOOST_NO_INTRINSIC_WCHAR_T
-
-//    VC++ 6.0 has member templates but they have numerous problems including
-//    cases of silent failure, so for safety we define:
-#     define BOOST_NO_MEMBER_TEMPLATES
-//    For VC++ experts wishing to attempt workarounds, we define:
-#     define BOOST_MSVC6_MEMBER_TEMPLATES
-
-#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-#     define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
-
-#     include <iterator>  // not sure this is the right way to do this -JGS
-#     if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
-        // a perfectly good implementation of std::iterator is supplied
-#     elif defined(__SGI_STL_ITERATOR)
-#       define BOOST_NO_STD_ITERATOR // No std::iterator in this case
-#     else
-#       define BOOST_MSVC_STD_ITERATOR 1
-#       define BOOST_NO_SLIST
-#       define BOOST_NO_HASH
-#       define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
-#       define BOOST_NO_STD_ALLOCATOR
-#       ifndef _CPPLIB_VER
-          // Updated Dinkum library defines this, and provides
-          // its own min and max definitions.
-#         define BOOST_NO_STD_MIN_MAX
-#         undef min
-#         undef max
-#       endif
-#       ifndef NOMINMAX
-          // avoid spurious NOMINMAX redefinition warning
-#         define NOMINMAX
-#       endif
-#     endif
-#     define BOOST_NO_STD_ITERATOR_TRAITS
-#     define BOOST_NO_CV_VOID_SPECIALIZATIONS
-
-
-// Make sure at least one standard library header is included so that library
-// implementation detection will work, even if no standard headers have been
-// included in front of a boost header. (Ed Brey 5 Jun 00)
-#     include <cstddef>
-
-// Determine if the standard library implementation is already pulling names
-// into std.  STLport defines the following if so. (Ed Brey 5 Jun 00)
-#     ifndef __STL_IMPORT_VENDOR_CSTD
-#       define BOOST_NO_STDC_NAMESPACE
-#     endif
-
-#   endif
-
-#   if defined BOOST_DECL_EXPORTS
-#     define BOOST_DECL __declspec(dllexport)
-#   else
-#     define BOOST_DECL __declspec(dllimport)
-#   endif
-
-# endif // Microsoft (excluding Intel/EDG frontend) 
-
-# ifndef BOOST_DECL
-#   define BOOST_DECL  // default for compilers not needing this decoration.
-# endif
-
-//  end of compiler specific portion  ----------------------------------------//
-
-#ifndef BOOST_STD_EXTENSION_NAMESPACE
-# define BOOST_STD_EXTENSION_NAMESPACE std
-#endif
-
-// Check for old name "BOOST_NMEMBER_TEMPLATES" for compatibility  -----------//
-// Don't use BOOST_NMEMBER_TEMPLATES. It is deprecated and will be removed soon.
-#if defined( BOOST_NMEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATES )
-  #define BOOST_NO_MEMBER_TEMPLATES
-#endif
-
-//  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
-//
-//  Because std::size_t usage is so common, even in boost headers which do not
-//  otherwise use the C library, the <cstddef> workaround is included here so
-//  that ugly workaround code need not appear in many other boost headers.
-//  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef> 
-//  must still be #included in the usual places so that <cstddef> inclusion
-//  works as expected with standard conforming compilers.  The resulting
-//  double inclusion of <cstddef> is harmless.
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-#   include <cstddef>
-    namespace std { using ::ptrdiff_t; using ::size_t; }
-    // using ::wchar_t; removed since wchar_t is a C++ built-in type (Ed Brey)
-# endif
-
-#ifdef BOOST_NO_STD_MIN_MAX
-namespace std {
-  template <class _Tp>
-  inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
-    return __b < __a ? __b : __a;
-  }
-  template <class _Tp>
-  inline const _Tp& max(const _Tp& __a, const _Tp& __b) {
-    return  __a < __b ? __b : __a;
-  }
-#ifdef BOOST_MSVC
-  inline long min(long __a, long __b) {
-    return __b < __a ? __b : __a;
-  }
-  inline long max(long __a, long __b) {
-    return  __a < __b ? __b : __a;
-  }
-#endif
-}
-#endif
-
-#endif  // BOOST_CONFIG_HPP
-
-
-
-
-
-
--- a/development/include/boost/detail/call_traits.hpp
+++ b/development/include/boost/detail/call_traits.hpp
@ -1,138 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-// call_traits: defines typedefs for function usage
-// (see libs/utility/call_traits.htm)
-
-/* Release notes:
-   23rd July 2000:
-      Fixed array specialization. (JM)
-      Added Borland specific fixes for reference types
-      (issue raised by Steve Cleary).
-*/
-
-#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
-#define BOOST_DETAIL_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-
-namespace boost{
-
-namespace detail{
-
-template <typename T, bool isp, bool b1, bool b2>
-struct ct_imp
-{
-   typedef const T& param_type;
-};
-
-template <typename T, bool isp>
-struct ct_imp<T, isp, true, true>
-{
-   typedef T const param_type;
-};
-
-template <typename T, bool b1, bool b2>
-struct ct_imp<T, true, b1, b2>
-{
-   typedef T const param_type;
-};
-
-}
-
-template <typename T>
-struct call_traits
-{
-public:
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   //
-   // C++ Builder workaround: we should be able to define a compile time
-   // constant and pass that as a single template parameter to ct_imp<T,bool>,
-   // however compiler bugs prevent this - instead pass three bool's to
-   // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
-   // of ct_imp to handle the logic. (JM)
-   typedef typename detail::ct_imp<T, ::boost::is_pointer<typename remove_const<T>::type>::value, ::boost::is_arithmetic<typename remove_const<T>::type>::value, sizeof(T) <= sizeof(void*)>::param_type param_type;
-};
-
-template <typename T>
-struct call_traits<T&>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T>
-struct call_traits<T&const>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&const volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-#endif
-
-template <typename T, std::size_t N>
-struct call_traits<T [N]>
-{
-private:
-   typedef T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-
-template <typename T, std::size_t N>
-struct call_traits<const T [N]>
-{
-private:
-   typedef const T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-
-}
-
-#endif // BOOST_DETAIL_CALL_TRAITS_HPP
--- a/development/include/boost/detail/ob_call_traits.hpp
+++ b/development/include/boost/detail/ob_call_traits.hpp
@ -1,125 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  Crippled version for crippled compilers:
-//  see libs/utility/call_traits.htm
-//
-
-/* Release notes:
-   01st October 2000:
-      Fixed call_traits on VC6, using "poor man's partial specialisation",
-      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
-      & Ulrich Eisenecker.
-*/
-
-#ifndef BOOST_OB_CALL_TRAITS_HPP
-#define BOOST_OB_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-
-namespace boost{
-
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-//
-// use member templates to emulate
-// partial specialisation:
-//
-namespace detail{
-
-template <class T>
-struct standard_call_traits
-{
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef const T& param_type;
-};
-template <class T>
-struct simple_call_traits
-{
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef const T param_type;
-};
-template <class T>
-struct reference_call_traits
-{
-   typedef T value_type;
-   typedef T reference;
-   typedef T const_reference;
-   typedef T param_type;
-};
-template <bool simple, bool reference>
-struct call_traits_chooser
-{
-   template <class T>
-   struct rebind
-   {
-      typedef standard_call_traits<T> type;
-   };
-};
-template <>
-struct call_traits_chooser<true, false>
-{
-   template <class T>
-   struct rebind
-   {
-      typedef simple_call_traits<T> type;
-   };
-};
-template <>
-struct call_traits_chooser<false, true>
-{
-   template <class T>
-   struct rebind
-   {
-      typedef reference_call_traits<T> type;
-   };
-};
-} // namespace detail
-template <typename T>
-struct call_traits
-{
-private:
-   typedef detail::call_traits_chooser<(is_pointer<T>::value || is_arithmetic<T>::value) && sizeof(T) <= sizeof(void*), is_reference<T>::value> chooser;
-   typedef typename chooser::template rebind<T> bound_type;
-   typedef typename bound_type::type call_traits_type;
-public:
-   typedef typename call_traits_type::value_type       value_type;
-   typedef typename call_traits_type::reference        reference;
-   typedef typename call_traits_type::const_reference  const_reference;
-   typedef typename call_traits_type::param_type       param_type;
-};
-
-#else
-//
-// sorry call_traits is completely non-functional
-// blame your broken compiler:
-//
-
-template <typename T>
-struct call_traits
-{
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef const T& param_type;
-};
-
-#endif // member templates
-
-}
-
-#endif // BOOST_OB_CALL_TRAITS_HPP
--- a/development/include/boost/smart_ptr.hpp
+++ b/development/include/boost/smart_ptr.hpp
@ -1,379 +0,0 @@
-//  Boost smart_ptr.hpp header file  -----------------------------------------//
-
-//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. Permission to copy,
-//  use, modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided "as is"
-//  without express or implied warranty, and with no claim as to its
-//  suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  19 Oct 00  Make shared_ptr ctor from auto_ptr explicit. (Robert Vugts) 
-//  24 Jul 00  Change throw() to // never throws.  See lib guidelines
-//             Exception-specification rationale. (Beman Dawes)
-//  22 Jun 00  Remove #if continuations to fix GCC 2.95.2 problem (Beman Dawes)
-//   1 Feb 00  Additional shared_ptr BOOST_NO_MEMBER_TEMPLATES workarounds
-//             (Dave Abrahams)
-//  31 Dec 99  Condition tightened for no member template friend workaround
-//             (Dave Abrahams)
-//  30 Dec 99  Moved BOOST_NMEMBER_TEMPLATES compatibility code to config.hpp
-//             (Dave Abrahams)
-//  30 Nov 99  added operator ==, operator !=, and std::swap and std::less
-//             specializations for shared types (Darin Adler)
-//  11 Oct 99  replaced op[](int) with op[](std::size_t) (Ed Brey, Valentin
-//             Bonnard), added shared_ptr workaround for no member template
-//             friends (Matthew Langston)
-//  25 Sep 99  added shared_ptr::swap and shared_array::swap (Luis Coelho).
-//  20 Jul 99  changed name to smart_ptr.hpp, #include <boost/config.hpp>,
-//             #include <boost/utility.hpp> and use boost::noncopyable
-//  17 May 99  remove scoped_array and shared_array operator*() as
-//             unnecessary (Beman Dawes)
-//  14 May 99  reorder code so no effects when bad_alloc thrown (Abrahams/Dawes)
-//  13 May 99  remove certain throw() specifiers to avoid generated try/catch
-//             code cost (Beman Dawes)
-//  11 May 99  get() added, conversion to T* placed in macro guard (Valentin
-//             Bonnard, Dave Abrahams, and others argued for elimination
-//             of the automatic conversion)
-//  28 Apr 99  #include <memory> fix (Valentin Bonnard)
-//  28 Apr 99  rename transfer() to share() for clarity (Dave Abrahams)
-//  28 Apr 99  remove unsafe shared_array template conversions(Valentin Bonnard)
-//  28 Apr 99  p(r) changed to p(r.px) for clarity (Dave Abrahams)
-//  21 Apr 99  reset() self assignment fix (Valentin Bonnard)
-//  21 Apr 99  dispose() provided to improve clarity (Valentin Bonnard)
-//  27 Apr 99  leak when new throws fixes (Dave Abrahams)
-//  21 Oct 98  initial Version (Greg Colvin/Beman Dawes)
-
-#ifndef BOOST_SMART_PTR_HPP
-#define BOOST_SMART_PTR_HPP
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-#include <cstddef>            // for std::size_t
-#include <memory>             // for std::auto_ptr
-#include <algorithm>          // for std::swap
-#include <boost/utility.hpp>  // for boost::noncopyable
-#include <functional>         // for std::less
-
-namespace boost {
-
-//  scoped_ptr  --------------------------------------------------------------//
-
-//  scoped_ptr mimics a built-in pointer except that it guarantees deletion
-//  of the object pointed to, either on destruction of the scoped_ptr or via
-//  an explicit reset().  scoped_ptr is a simple solution for simple needs;
-//  see shared_ptr (below) or std::auto_ptr if your needs are more complex.
-
-template<typename T> class scoped_ptr : noncopyable {
-
-  T* ptr;
-
- public:
-  typedef T element_type;
-
-  explicit scoped_ptr( T* p=0 ) : ptr(p) {}  // never throws
-  ~scoped_ptr()                 { delete ptr; }
-
-  void reset( T* p=0 )          { if ( ptr != p ) { delete ptr; ptr = p; } }
-  T& operator*() const          { return *ptr; }  // never throws
-  T* operator->() const         { return ptr; }  // never throws
-  T* get() const                { return ptr; }  // never throws
-#ifdef BOOST_SMART_PTR_CONVERSION
-  // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-  operator T*() const           { return ptr; }  // never throws 
-#endif
-  };  // scoped_ptr
-
-//  scoped_array  ------------------------------------------------------------//
-
-//  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
-//  is guaranteed, either on destruction of the scoped_array or via an explicit
-//  reset(). See shared_array or std::vector if your needs are more complex.
-
-template<typename T> class scoped_array : noncopyable {
-
-  T* ptr;
-
- public:
-  typedef T element_type;
-
-  explicit scoped_array( T* p=0 ) : ptr(p) {}  // never throws
-  ~scoped_array()                    { delete [] ptr; }
-
-  void reset( T* p=0 )               { if ( ptr != p ) {delete [] ptr; ptr=p;} }
-
-  T* get() const                     { return ptr; }  // never throws
-#ifdef BOOST_SMART_PTR_CONVERSION
-  // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-  operator T*() const                { return ptr; }  // never throws
-#else 
-  T& operator[](std::size_t i) const { return ptr[i]; }  // never throws
-#endif
-  };  // scoped_array
-
-//  shared_ptr  --------------------------------------------------------------//
-
-//  An enhanced relative of scoped_ptr with reference counted copy semantics.
-//  The object pointed to is deleted when the last shared_ptr pointing to it
-//  is destroyed or reset.
-
-template<typename T> class shared_ptr {
-  public:
-   typedef T element_type;
-
-   explicit shared_ptr(T* p =0) : px(p) {
-      try { pn = new long(1); }  // fix: prevent leak if new throws
-      catch (...) { delete p; throw; } 
-   }
-
-   shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); }  // never throws
-
-   ~shared_ptr() { dispose(); }
-
-   shared_ptr& operator=(const shared_ptr& r) {
-      share(r.px,r.pn);
-      return *this;
-   }
-
-#if !defined( BOOST_NO_MEMBER_TEMPLATES )
-   template<typename Y>
-      shared_ptr(const shared_ptr<Y>& r) : px(r.px) {  // never throws 
-         ++*(pn = r.pn); 
-      }
-#ifndef BOOST_NO_AUTO_PTR
-   template<typename Y>
-      explicit shared_ptr(std::auto_ptr<Y>& r) { 
-         pn = new long(1); // may throw
-         px = r.release(); // fix: moved here to stop leak if new throws
-      }
-#endif 
-
-   template<typename Y>
-      shared_ptr& operator=(const shared_ptr<Y>& r) { 
-         share(r.px,r.pn);
-         return *this;
-      }
-
-#ifndef BOOST_NO_AUTO_PTR
-   template<typename Y>
-      shared_ptr& operator=(std::auto_ptr<Y>& r) {
-         // code choice driven by guarantee of "no effect if new throws"
-         if (*pn == 1) { delete px; }
-         else { // allocate new reference counter
-           long * tmp = new long(1); // may throw
-           --*pn; // only decrement once danger of new throwing is past
-           pn = tmp;
-         } // allocate new reference counter
-         px = r.release(); // fix: moved here so doesn't leak if new throws 
-         return *this;
-      }
-#endif
-#else
-#ifndef BOOST_NO_AUTO_PTR
-      explicit shared_ptr(std::auto_ptr<T>& r) { 
-         pn = new long(1); // may throw
-         px = r.release(); // fix: moved here to stop leak if new throws
-      } 
-
-      shared_ptr& operator=(std::auto_ptr<T>& r) {
-         // code choice driven by guarantee of "no effect if new throws"
-         if (*pn == 1) { delete px; }
-         else { // allocate new reference counter
-           long * tmp = new long(1); // may throw
-           --*pn; // only decrement once danger of new throwing is past
-           pn = tmp;
-         } // allocate new reference counter
-         px = r.release(); // fix: moved here so doesn't leak if new throws 
-         return *this;
-      }
-#endif
-#endif
-
-   void reset(T* p=0) {
-      if ( px == p ) return;  // fix: self-assignment safe
-      if (--*pn == 0) { delete px; }
-      else { // allocate new reference counter
-        try { pn = new long; }  // fix: prevent leak if new throws
-        catch (...) {
-          ++*pn;  // undo effect of --*pn above to meet effects guarantee 
-          delete p;
-          throw;
-        } // catch
-      } // allocate new reference counter
-      *pn = 1;
-      px = p;
-   } // reset
-
-   T& operator*() const          { return *px; }  // never throws
-   T* operator->() const         { return px; }  // never throws
-   T* get() const                { return px; }  // never throws
- #ifdef BOOST_SMART_PTR_CONVERSION
-   // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-   operator T*() const           { return px; }  // never throws 
- #endif
-
-   long use_count() const        { return *pn; }  // never throws
-   bool unique() const           { return *pn == 1; }  // never throws
-
-   void swap(shared_ptr<T>& other)  // never throws
-     { std::swap(px,other.px); std::swap(pn,other.pn); }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
-#if defined(BOOST_NO_MEMBER_TEMPLATES) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
-   private:
-#endif
-
-   T*     px;     // contained pointer
-   long*  pn;     // ptr to reference counter
-
-// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
-#if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
-   template<typename Y> friend class shared_ptr;
-#endif
-
-   void dispose() { if (--*pn == 0) { delete px; delete pn; } }
-
-   void share(T* rpx, long* rpn) {
-      if (pn != rpn) {
-         dispose();
-         px = rpx;
-         ++*(pn = rpn);
-      }
-   } // share
-};  // shared_ptr
-
-template<typename T, typename U>
-  inline bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b)
-    { return a.get() == b.get(); }
-
-template<typename T, typename U>
-  inline bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b)
-    { return a.get() != b.get(); }
-
-//  shared_array  ------------------------------------------------------------//
-
-//  shared_array extends shared_ptr to arrays.
-//  The array pointed to is deleted when the last shared_array pointing to it
-//  is destroyed or reset.
-
-template<typename T> class shared_array {
-  public:
-   typedef T element_type;
-
-   explicit shared_array(T* p =0) : px(p) {
-      try { pn = new long(1); }  // fix: prevent leak if new throws
-      catch (...) { delete [] p; throw; } 
-   }
-
-   shared_array(const shared_array& r) : px(r.px)  // never throws
-      { ++*(pn = r.pn); }
-
-   ~shared_array() { dispose(); }
-
-   shared_array& operator=(const shared_array& r) {
-      if (pn != r.pn) {
-         dispose();
-         px = r.px;
-         ++*(pn = r.pn);
-      }
-      return *this;
-   } // operator=
-
-   void reset(T* p=0) {
-      if ( px == p ) return;  // fix: self-assignment safe
-      if (--*pn == 0) { delete [] px; }
-      else { // allocate new reference counter
-        try { pn = new long; }  // fix: prevent leak if new throws
-        catch (...) {
-          ++*pn;  // undo effect of --*pn above to meet effects guarantee 
-          delete [] p;
-          throw;
-        } // catch
-      } // allocate new reference counter
-      *pn = 1;
-      px = p;
-   } // reset
-
-   T* get() const                     { return px; }  // never throws
- #ifdef BOOST_SMART_PTR_CONVERSION
-   // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-   operator T*() const                { return px; }  // never throws
- #else 
-   T& operator[](std::size_t i) const { return px[i]; }  // never throws
- #endif
-
-   long use_count() const             { return *pn; }  // never throws
-   bool unique() const                { return *pn == 1; }  // never throws
-
-   void swap(shared_array<T>& other)  // never throws
-     { std::swap(px,other.px); std::swap(pn,other.pn); }
-
-  private:
-
-   T*     px;     // contained pointer
-   long*  pn;     // ptr to reference counter
-
-   void dispose() { if (--*pn == 0) { delete [] px; delete pn; } }
-
-};  // shared_array
-
-template<typename T>
-  inline bool operator==(const shared_array<T>& a, const shared_array<T>& b)
-    { return a.get() == b.get(); }
-
-template<typename T>
-  inline bool operator!=(const shared_array<T>& a, const shared_array<T>& b)
-    { return a.get() != b.get(); }
-
-} // namespace boost
-
-//  specializations for things in namespace std  -----------------------------//
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace std {
-
-// Specialize std::swap to use the fast, non-throwing swap that's provided
-// as a member function instead of using the default algorithm which creates
-// a temporary and uses assignment.
-
-template<typename T>
-  inline void swap(boost::shared_ptr<T>& a, boost::shared_ptr<T>& b)
-    { a.swap(b); }
-
-template<typename T>
-  inline void swap(boost::shared_array<T>& a, boost::shared_array<T>& b)
-    { a.swap(b); }
-
-// Specialize std::less so we can use shared pointers and arrays as keys in
-// associative collections.
-
-// It's still a controversial question whether this is better than supplying
-// a full range of comparison operators (<, >, <=, >=).
-
-template<typename T>
-  struct less< boost::shared_ptr<T> >
-    : binary_function<boost::shared_ptr<T>, boost::shared_ptr<T>, bool>
-  {
-    bool operator()(const boost::shared_ptr<T>& a,
-        const boost::shared_ptr<T>& b) const
-      { return less<T*>()(a.get(),b.get()); }
-  };
-
-template<typename T>
-  struct less< boost::shared_array<T> >
-    : binary_function<boost::shared_array<T>, boost::shared_array<T>, bool>
-  {
-    bool operator()(const boost::shared_array<T>& a,
-        const boost::shared_array<T>& b) const
-      { return less<T*>()(a.get(),b.get()); }
-  };
-
-} // namespace std
-
-#endif  // ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif  // BOOST_SMART_PTR_HPP
-
-
--- a/development/include/boost/timer.hpp
+++ b/development/include/boost/timer.hpp
@ -1,57 +0,0 @@
-//  boost timer.hpp header file  ---------------------------------------------//
-
-//  (C) Copyright Beman Dawes 1994-99. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
-//  16 Jul 99  Second beta
-//   6 Jul 99  Initial boost version
-
-#ifndef BOOST_TIMER_HPP
-#define BOOST_TIMER_HPP
-
-#include <boost/smart_ptr.hpp>
-
-namespace boost {
-
-//  timer  -------------------------------------------------------------------//
-
-//  A timer object measures elapsed time.
-
-//  It is recommended that implementations measure wall clock rather than CPU
-//  time since the intended use is performance measurement on systems where
-//  total elapsed time is more important than just process or CPU time.
-
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
-//  due to implementation limitations.  The accuracy of timings depends on the
-//  accuracy of timing information provided by the underlying platform, and
-//  this varies a great deal from platform to platform.
-
-class timer {
-
-public:
-         timer();                        // postcondition: elapsed()==0
-         timer( const timer& src );      // post: elapsed()==src.elapsed()
-        ~timer();
-  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
-  void   restart();                      // post: elapsed()==0
-  double elapsed() const;                // return elapsed time in seconds
-
-  double elapsed_max() const;  // return estimated maximum value for elapsed()
-  // Portability warning: elapsed_max() may return too high a value on systems
-  // where std::clock_t overflows or resets at surprising values.
-  double elapsed_min() const;            // return minimum value for elapsed()
-
-private:
-  class _timer;
-  scoped_ptr<_timer> _imp;               // hide implementation details
-  }; // timer
-
-} // namespace boost
-
-#endif  // BOOST_TIMER_HPP
--- a/development/include/boost/type_traits.hpp
+++ b/development/include/boost/type_traits.hpp
@ -1,42 +0,0 @@
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//  See boost/detail/type_traits.hpp and boost/detail/ob_type_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#define BOOST_TYPE_TRAITS_HPP
-
-#include <boost/type_traits/fwd.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/type_traits/arithmetic_traits.hpp>
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/type_traits/composite_traits.hpp>
-#include <boost/type_traits/alignment_traits.hpp>
-#include <boost/type_traits/object_traits.hpp>
-#include <boost/type_traits/transform_traits.hpp>
-#include <boost/type_traits/same_traits.hpp>
-
-/**************************************************************************/
-
-//
-// undefine helper macro's:
-//
-#undef BOOST_IS_CLASS
-#undef BOOST_IS_ENUM
-#undef BOOST_IS_UNION
-#undef BOOST_IS_POD
-#undef BOOST_IS_EMPTY
-#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
-#undef BOOST_HAS_TRIVIAL_COPY
-#undef BOOST_HAS_TRIVIAL_ASSIGN
-#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
-
-#endif // BOOST_TYPE_TRAITS_HPP
-
-
-
--- a/development/include/boost/type_traits/alignment_traits.hpp
+++ b/development/include/boost/type_traits/alignment_traits.hpp
@ -1,82 +0,0 @@
-
-//  (C) Copyright John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//
-// defines alignment_of:
-
-#ifndef ALIGNMENT_TYPE_TRAITS_HPP
-#define ALIGNMENT_TYPE_TRAITS_HPP
-
-#include <cstdlib>
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-
-namespace boost{
-//
-// get the alignment of some arbitrary type:
-namespace detail{
-
-template <class T>
-struct alignment_of_hack
-{
-   char c;
-   T t;
-   alignment_of_hack();
-};
-
-template <unsigned A, unsigned S>
-struct alignment_logic
-{
-   BOOST_DECL_MC(std::size_t, value, A < S ? A : S);
-};
-
-} // namespace detail
-
-template <class T>
-struct alignment_of
-{
-   BOOST_DECL_MC(std::size_t, value,
-      (::boost::detail::alignment_logic<
-         sizeof(detail::alignment_of_hack<T>) - sizeof(T),
-         sizeof(T)
-      >::value));
-};
-
-//
-// references have to be treated specially, assume
-// that a reference is just a special pointer:
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct alignment_of<T&>
-{
-public:
-   BOOST_DECL_MC(std::size_t, value, alignment_of<T*>::value);
-};
-#endif
-//
-// void has to be treated specially:
-template <>
-struct alignment_of<void>
-{ BOOST_DECL_MC(std::size_t, value, 0); };
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct alignment_of<const void>
-{ BOOST_DECL_MC(std::size_t, value, 0); };
-template <>
-struct alignment_of<volatile void>
-{ BOOST_DECL_MC(std::size_t, value, 0); };
-template <>
-struct alignment_of<const volatile void>
-{ BOOST_DECL_MC(std::size_t, value, 0); };
-#endif
-
-} // namespace boost
-
-#endif // ALIGNMENT_TYPE_TRAITS_HPP
-
- 
--- a/development/include/boost/type_traits/arithmetic_traits.hpp
+++ b/development/include/boost/type_traits/arithmetic_traits.hpp
@ -1,262 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines traits classes for arithmetic types:
-//  is_void, is_integral, is_float, is_arithmetic, is_fundamental.
-//
-
-
-#ifndef ARITHMETIC_TYPE_TRAITS_HPP
-#define ARITHMETIC_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-
-namespace boost{
-
-//* is a type T void - is_void<T>
-template <typename T> struct is_void{ BOOST_DECL_MC(bool, value, false); };
-template <> struct is_void<void>{ BOOST_DECL_MC(bool, value, true); };
-
-//* is a type T an integral type described in the standard (3.9.1p3)
-template <typename T> struct is_integral
-{ BOOST_DECL_MC(bool, value, false); };
-template <> struct is_integral<unsigned char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<unsigned short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<unsigned int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<unsigned long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<signed char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<signed short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<signed int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<signed long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<char>
-{ BOOST_DECL_MC(bool, value, true); };
-#ifndef BOOST_MSVC
-template <> struct is_integral<wchar_t>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-template <> struct is_integral<bool>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
-template <> struct is_integral<unsigned long long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<long long>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_integral<unsigned __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<__int64>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-
-//* is a type T a floating-point type described in the standard (3.9.1p8)
-template <typename T> struct is_float
-{ BOOST_DECL_MC(bool, value, false); };
-template <> struct is_float<float>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<double>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<long double>
-{ BOOST_DECL_MC(bool, value, true); };
-
-//
-// declare cv-qualified specialisations of these templates only
-// if BOOST_NO_CV_SPECIALIZATIONS is not defined:
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_void<const void>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_void<volatile void>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_void<const volatile void>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-#ifndef BOOST_NO_CV_SPECIALIZATIONS
-// const-variations:
-template <> struct is_integral<const unsigned char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const unsigned short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const unsigned int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const unsigned long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const signed char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const signed short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const signed int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const signed long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const char>
-{ BOOST_DECL_MC(bool, value, true); };
-#ifndef BOOST_MSVC
-template <> struct is_integral<const wchar_t>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-template <> struct is_integral<const bool>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
-template <> struct is_integral<const unsigned long long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const long long>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif  // ULLONG_MAX
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_integral<const unsigned __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif //__int64
-
-template <> struct is_float<const float>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<const double>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<const long double>
-{ BOOST_DECL_MC(bool, value, true); };
-
-// volatile-variations:
-template <> struct is_integral<volatile  unsigned char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  unsigned short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  unsigned int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  unsigned long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  signed char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  signed short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  signed int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  signed long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  char>
-{ BOOST_DECL_MC(bool, value, true); };
-#ifndef BOOST_MSVC
-template <> struct is_integral<volatile  wchar_t>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-template <> struct is_integral<volatile  bool>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#ifdef ULLONG_MAX
-template <> struct is_integral<volatile  unsigned long long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  long long>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif  // ULLONG_MAX
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_integral<volatile  unsigned __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<volatile  __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif //__int64
-
-template <> struct is_float<volatile  float>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<volatile  double>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<volatile  long double>
-{ BOOST_DECL_MC(bool, value, true); };
-
-// const-volatile-variations:
-template <> struct is_integral<const volatile unsigned char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile unsigned short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile unsigned int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile unsigned long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile signed char>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile signed short>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile signed int>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile signed long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile char>
-{ BOOST_DECL_MC(bool, value, true); };
-#ifndef BOOST_MSVC
-template <> struct is_integral<const volatile wchar_t>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-template <> struct is_integral<const volatile bool>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#ifdef ULLONG_MAX
-template <> struct is_integral<const volatile unsigned long long>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile long long>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif  // ULLONG_MAX
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_integral<const volatile unsigned __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_integral<const volatile __int64>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif //__int64
-
-template <> struct is_float<const volatile float>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<const volatile double>
-{ BOOST_DECL_MC(bool, value, true); };
-template <> struct is_float<const volatile long double>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#endif // BOOST_NO_CV_SPECIALIZATIONS
-
-//* is a type T an arithmetic type described in the standard (3.9.1p8)
-template <typename T> 
-struct is_arithmetic
-{ 
-	BOOST_DECL_MC(bool, value, 
-		(::boost::type_traits::ice_or< 
-			::boost::is_integral<T>::value, 
-			::boost::is_float<T>::value
-		>::value)); 
-};
-
-//* is a type T a fundamental type described in the standard (3.9.1)
-template <typename T> 
-struct is_fundamental
-{ 
-	BOOST_DECL_MC(bool, value, 
-		(::boost::type_traits::ice_or< 
-			::boost::is_arithmetic<T>::value, 
-			::boost::is_void<T>::value
-		>::value)); 
-};
-
-} // namespace boost
-
-#endif
-
-
-
-
-
--- a/development/include/boost/type_traits/composite_traits.hpp
+++ b/development/include/boost/type_traits/composite_traits.hpp
@ -1,357 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines traits classes for composite types:
-//  is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union.
-//
-//    Some workarounds in here use ideas suggested from "Generic<Programming>: 
-//    Mappings between Types and Values" 
-//    by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
-//    Mat Marcus and Jesse Jones posted a version of is_pointer very similar to this one
-//    on the boost list (Copyright 2000 Adobe Systems Incorporated and others. 
-//    All rights reserved.).
-//    Fixes for is_array are based on a newgroup posting by Jonathan Lundquist.
-
-#ifndef COMPOSITE_TYPE_TRAITS_HPP
-#define COMPOSITE_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP
-#include <boost/type_traits/conversion_traits.hpp>
-#endif
-#ifndef CV_TYPE_TRAITS_HPP
-#include <boost/type_traits/cv_traits.hpp>
-#endif
-#ifndef ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-
-namespace boost{
-
-/**********************************************
- *
- * is_array
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_array
-{ BOOST_DECL_MC(bool, value, false); };
-template <typename T, std::size_t N> struct is_array<T[N]>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, std::size_t N> struct is_array<const T[N]>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, std::size_t N> struct is_array<volatile T[N]>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, std::size_t N> struct is_array<const volatile T[N]>
-{ BOOST_DECL_MC(bool, value, true); };
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-   struct pointer_helper
-   {
-      pointer_helper(const volatile void*);
-   };
-   yes_type is_pointer_helper(pointer_helper);
-   no_type is_pointer_helper(...);
-   template <class T>
-   yes_type is_pointer_helper3(T (*)(void));
-   template <class T, class A1>
-   yes_type is_pointer_helper3(T (*)(A1));
-   template <class T, class A1, class A2>
-   yes_type is_pointer_helper3(T (*)(A1, A2));
-   template <class T, class A1, class A2, class A3>
-   yes_type is_pointer_helper3(T (*)(A1, A2, A3));
-   no_type is_pointer_helper3(...);
-
-   yes_type is_array_helper(const volatile void*, const volatile void*);
-   template <class T>
-   no_type is_array_helper(T*const volatile*, const volatile void*);
-   no_type is_array_helper(...);
-} // namespace detail
-template <typename T> 
-struct is_array
-{ 
-private:
-   static T t;
-public:
-   BOOST_DECL_MC(bool, value, (1 == sizeof(detail::is_array_helper(&t, t)))
-                 & !is_reference<T>::value
-                 & !(1 == sizeof(detail::is_pointer_helper3(t))) );
-};
-template <> 
-struct is_array<void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> 
-struct is_array<const void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <> 
-struct is_array<volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <> 
-struct is_array<const volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#endif
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-/**********************************************
- *
- * is_pointer
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-template <typename T> struct is_pointer_helper
-{ BOOST_DECL_MC(bool, value, false); };
-template <typename T> struct is_pointer_helper<T*>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T> struct is_pointer_helper<T*const>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T> struct is_pointer_helper<T*volatile>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T> struct is_pointer_helper<T*const volatile>
-{ BOOST_DECL_MC(bool, value, true); };
-} // namespace detail
-template <typename T> struct is_pointer
-{ BOOST_DECL_MC(bool, value, (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T>::value, !::boost::is_member_pointer<T>::value>::value)); };
-#else
-template <typename T>
-struct is_pointer 
-{ 
-private:
-   static T t;
-public:
-   BOOST_DECL_MC(bool, value,
-                (::boost::type_traits::ice_and<
-                    !::boost::is_reference<T>::value,
-                    !::boost::is_array<T>::value,
-                    (::boost::type_traits::ice_or<
-                       (1 == sizeof(detail::is_pointer_helper(t))),
-                       (1 == sizeof(detail::is_pointer_helper3(t)))
-                    >::value)
-                >::value ) );
-};
-template <>
-struct is_pointer <void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_pointer <const void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <>
-struct is_pointer <volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <>
-struct is_pointer <const volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#endif
-#endif
-
-/**********************************************
- *
- * is_reference
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_reference 
-{ BOOST_DECL_MC(bool, value, false); };
-template <typename T> struct is_reference<T&> 
-{ BOOST_DECL_MC(bool, value, true); };
-#if defined(__BORLANDC__)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct is_reference<T&const> 
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T> struct is_reference<T&volatile> 
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T> struct is_reference<T&const volatile> 
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-#else
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-template <typename T> struct is_reference
-{ 
-private:
-   typedef T const volatile cv_t;
-public:
-   BOOST_DECL_MC(bool, value, (::boost::type_traits::ice_or<!::boost::is_const<cv_t>::value, !::boost::is_volatile<cv_t>::value>::value));
-};
-template <> struct is_reference<void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_reference<const void>
-{ BOOST_DECL_MC(bool, value, false); };
-template <> struct is_reference<volatile void>
-{ BOOST_DECL_MC(bool, value, false); };
-template <> struct is_reference<const volatile void>
-{ BOOST_DECL_MC(bool, value, false); };
-#endif
-
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-#endif
-
-/**********************************************
- *
- * is_union
- *
- **********************************************/
-template <typename T> struct is_union
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   BOOST_DECL_MC(bool, value, BOOST_IS_UNION(cvt));
-};
-
-/**********************************************
- *
- * is_enum
- *
- **********************************************/
-namespace detail{
-struct int_convertible
-{
-   int_convertible(int);
-};
-} // namespace detail
-#ifndef __BORLANDC__
-template <typename T> struct is_enum
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         !::boost::is_arithmetic<T>::value,
-         !::boost::is_reference<T>::value,
-         ::boost::is_convertible<T, detail::int_convertible>::value
-      >::value));
-};
-#else // __BORLANDC__
-//
-// buggy is_convertible prevents working 
-// implementation of is_enum:
-template <typename T> struct is_enum
-{
-public:
-   BOOST_DECL_MC(bool, value, BOOST_IS_ENUM(T));
-};
-#endif
-
-/**********************************************
- *
- * is_member_pointer
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_member_pointer
-{ BOOST_DECL_MC(bool, value, false); };
-template <typename T, typename U> struct is_member_pointer<U T::*>
-{ BOOST_DECL_MC(bool, value, true); };
-#ifdef __GNUC__
-// gcc workaround (JM 02 Oct 2000)
-template <typename T, typename U> struct is_member_pointer<U (T::*)(void)>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, typename U, typename A1> struct is_member_pointer<U (T::*)(A1)>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, typename U, typename A1, typename A2> struct is_member_pointer<U (T::*)(A1, A2)>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, typename U, typename A1, typename A2, typename A3> struct is_member_pointer<U (T::*)(A1, A2, A3)>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, typename U, typename A1, typename A2, typename A3, typename A4> struct is_member_pointer<U (T::*)(A1, A2, A3, A4)>
-{ BOOST_DECL_MC(bool, value, true); };
-template <typename T, typename U, typename A1, typename A2, typename A3, typename A4, typename A5> struct is_member_pointer<U (T::*)(A1, A2, A3, A4, A5)>
-{ BOOST_DECL_MC(bool, value, true); };
-#endif
-#else
-namespace detail{
-   template <class T, class U>
-   yes_type is_member_pointer_helper(T (U::*));
-   template <class T, class U>
-   yes_type is_member_pointer_helper(T (U::*)(void));
-   template <class T, class U, class A1>
-   yes_type is_member_pointer_helper(T (U::*)(A1));
-   template <class T, class U, class A1, class A2>
-   yes_type is_member_pointer_helper(T (U::*)(A1, A2));
-   template <class T, class U, class A1, class A2, class A3>
-   yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3));
-   template <class T, class U, class A1, class A2, class A3, class A4>
-   yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3, A4));
-   template <class T, class U, class A1, class A2, class A3, class A4, class A5>
-   yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3, A4, A5));
-   no_type is_member_pointer_helper(...);
-}
-template <typename T> 
-struct is_member_pointer
-{ 
-private:
-   static T t;
-public:
-   BOOST_DECL_MC(bool, value, (1 == sizeof(detail::is_member_pointer_helper(t))) );
-};
-template <> 
-struct is_member_pointer<void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> 
-struct is_member_pointer<const void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <> 
-struct is_member_pointer<volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-template <> 
-struct is_member_pointer<const volatile void>
-{ 
-   BOOST_DECL_MC(bool, value, false);
-};
-#endif
-
-#endif
-
-
-} // namespace boost
-
-#endif // COMPOSITE_TYPE_TRAITS_HPP
- 
-
-
-
-
--- a/development/include/boost/type_traits/conversion_traits.hpp
+++ b/development/include/boost/type_traits/conversion_traits.hpp
@ -1,224 +0,0 @@
-
-// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com)
-// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu)
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy and use this software is granted, 
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted, 
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP
-#define BOOST_CONVERSION_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-//
-// is one type convertable to another?
-//
-// there are multiple versions of the is_convertible
-// template, almost every compiler seems to require its
-// own version.
-//
-// Thanks to Andrei Alexandrescu for the original version of the
-// conversion detection technique!
-//
-
-namespace boost{
-
-#ifdef BOOST_MSVC
-
-//
-// MS specific version:
-//
-namespace detail{
-
-   // This workaround is necessary to handle when From is void
-   // which is normally taken care of by the partial specialization
-   // of the is_convertible class.
-   using ::boost::type_traits::yes_type;
-   using ::boost::type_traits::no_type;
-
-  struct from_not_void_conversion {
-    template <class From, class To>
-    struct bind {
-      static no_type check(...);
-      static yes_type check(To);
-    public:
-      void foo(); // avoid warning about all members being private
-      static From from;
-      enum { exists = sizeof( check(from) ) == sizeof(yes_type) };
-    };
-  };
-  struct from_is_void_conversion {
-    template <class From, class To>
-    struct bind {
-       enum { exists = ::boost::is_void<To>::value };
-    };
-  };
-
-  template <class From>
-  struct conversion_helper {
-    typedef from_not_void_conversion type;
-  };
-  template <>
-  struct conversion_helper<void> {
-    typedef from_is_void_conversion type;
-  };
-} // namespace detail
-
-template <class From, class To>
-struct is_convertible
-{
- typedef typename detail::conversion_helper<From>::type Selector;
- typedef Selector::template bind<From,To> Conversion;
-public:
- enum { value = Conversion::exists };
-};
-
-#elif defined(__BORLANDC__)
-//
-// special version for Borland compilers
-// this version breaks when used for some
-// UDT conversions:
-//
-template <class From, class To>
-struct is_convertible_helper
-{
-private:
-   // This workaround for Borland breaks the EDG C++ frontend,
-   // so we only use it for Borland.
-   template <class T>
-   struct checker
-   {
-      static type_traits::no_type check(...);
-      static type_traits::yes_type check(T);
-   };
-   static From from;
-public:
-   static const bool value = sizeof( checker<To>::check(from) ) == sizeof(type_traits::yes_type);
-
-   void foo(); // avoid warning about all members being private
-};
-
-template <class From, class To>
-struct is_convertible
-{
-private:
-   typedef is_convertible_helper<From, To> c_type;
-   enum{ v = c_type::value };
-   char force_it[v ? 1 : 2];
-public:
-   static const bool value = is_convertible_helper<From, To>::value;
-};
-
-template <class From>
-struct is_convertible<From, void>
-{
-   static const bool value = false;
-};
-template <class To>
-struct is_convertible<void, To>
-{
-   static const bool value = false;
-};
-template <>
-struct is_convertible<void, void>
-{
-   static const bool value = true;
-};
-
-#elif defined(__GNUC__)
-//
-// special version for gcc compiler
-//
-namespace detail{
-   struct any_conversion
-   {
-      template <class T>
-      any_conversion(const T&);
-   };
-   template <class T>
-   struct checker
-   {
-      static boost::type_traits::no_type check(any_conversion ...);
-      static boost::type_traits::yes_type check(T, int);
-   };
-} // namespace detail
-template <class From, class To>
-struct is_convertible
-{
-private:
-   static From from;
-public:
-   static const bool value = sizeof( detail::checker<To>::check(from, 0) ) == sizeof(type_traits::yes_type);
-
-   void foo(); // avoid warning about all members being private
-};
-
-template <class From>
-struct is_convertible<From, void>
-{
-   static const bool value = false;
-};
-template <class To>
-struct is_convertible<void, To>
-{
-   static const bool value = false;
-};
-template <>
-struct is_convertible<void, void>
-{
-   static const bool value = true;
-};
-
-#else
-
-template <class From, class To>
-struct is_convertible
-{
-private:
-   static type_traits::no_type check(...);
-   static type_traits::yes_type check(To);
-   static From from;
-public:
-   BOOST_DECL_MC(bool, value, sizeof( check(from) ) == sizeof(type_traits::yes_type));
-   void foo(); // avoid warning about all members being private
-};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class From>
-struct is_convertible<From, void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-
-template <class To>
-struct is_convertible<void, To>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-
-template <>
-struct is_convertible<void, void>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // is_convertible
-
-} // namespace boost
-
-#endif  // include guard
--- a/development/include/boost/type_traits/cv_traits.hpp
+++ b/development/include/boost/type_traits/cv_traits.hpp
@ -1,214 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines traits classes for cv-qualified types:
-//  is_const, is_volatile, remove_const, remove_volatile, remove_cv.
-//
-
-#ifndef CV_TYPE_TRAITS_HPP
-#define CV_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-
-namespace boost{
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-//
-// implementation helper:
-//
-template <class T>
-struct cv_traits_imp{};
-
-template <class T>
-struct cv_traits_imp<T*>
-{
-   BOOST_DECL_MC(bool, is_const, false);
-   BOOST_DECL_MC(bool, is_volatile, false);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<const T*>
-{
-   BOOST_DECL_MC(bool, is_const, true);
-   BOOST_DECL_MC(bool, is_volatile, false);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<volatile T*>
-{
-   BOOST_DECL_MC(bool, is_const, false);
-   BOOST_DECL_MC(bool, is_volatile, true);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<const volatile T*>
-{
-   BOOST_DECL_MC(bool, is_const, true);
-   BOOST_DECL_MC(bool, is_volatile, true);
-   typedef T unqualified_type;
-};
-
-template <class T, bool is_vol>
-struct remove_const_helper
-{
-   typedef T type;
-};
-template <class T>
-struct remove_const_helper<T, true>
-{
-   typedef volatile T type;
-};
-
-template <class T, bool is_vol>
-struct remove_volatile_helper
-{
-   typedef T type;
-};
-template <class T>
-struct remove_volatile_helper<T, true>
-{
-   typedef const T type;
-};
-
-} // namespace detail
-
-// * convert a type T to a non-volatile type - remove_volatile<T>
-template <typename T>
-struct remove_volatile
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
-   typedef typename detail::remove_volatile_helper<uq_type, ::boost::is_const<T>::value>::type type;
-};
-template <typename T> struct remove_volatile<T&>{ typedef T& type; };
-
-// * convert a type T to non-const type - remove_const<T>
-template <typename T>
-struct remove_const
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
-   typedef typename detail::remove_const_helper<uq_type, ::boost::is_volatile<T>::value>::type type;
-};
-template <typename T> struct remove_const<T&>{ typedef T& type; };
-
-//  convert a type T to a non-cv-qualified type - remove_cv<T>
-template <typename T>
-struct remove_cv
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type type;
-};
-template <typename T> struct remove_cv<T&>{ typedef T& type; };
-
-//* is a type T  declared const - is_const<T>
-template <typename T>
-struct is_const
-{
-   BOOST_DECL_MC(bool, value, detail::cv_traits_imp<T*>::is_const);
-};
-
-//* is a type T declared volatile - is_volatile<T>
-template <typename T>
-struct is_volatile
-{
-   BOOST_DECL_MC(bool, value, detail::cv_traits_imp<T*>::is_volatile);
-};
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-// The following three don't work:
-template <typename T> struct remove_volatile{ typedef T type; };
-template <typename T> struct remove_const{ typedef T type; };
-template <typename T> struct remove_cv{ typedef T type; };
-
-namespace detail{
-   using ::boost::type_traits::yes_type;
-   using ::boost::type_traits::no_type;
-   yes_type is_const_helper(const volatile void*);
-   no_type is_const_helper(volatile void *);
-   yes_type is_volatile_helper(const volatile void*);
-   no_type is_volatile_helper(const void *);
-}
-
-template <typename T>
-struct is_const
-{ 
-private:
-   static T t;
-public:
-   BOOST_DECL_MC(bool, value, (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(&t))));
-};
-
-template <>
-struct is_const<void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_const<const void>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-template <>
-struct is_const<volatile void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-template <>
-struct is_const<const volatile void>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-#endif
-
-template <typename T>
-struct is_volatile
-{
-private:
-   static T t;
-public:
-   BOOST_DECL_MC(bool, value, (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(&t))));
-};
-
-template <>
-struct is_volatile<void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_volatile<const void>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-template <>
-struct is_volatile<volatile void>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-template <>
-struct is_volatile<const volatile void>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-#endif
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-} // namespace boost
-
-
-#endif // CV_TYPE_TRAITS_HPP
-
-
--- a/development/include/boost/type_traits/fwd.hpp
+++ b/development/include/boost/type_traits/fwd.hpp
@ -1,140 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  forward declarations of type_traits classes
-//
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#define BOOST_FWD_TYPE_TRAITS_HPP
-
-#include <cstdlib>
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-//
-// Helper macros for builtin compiler support.
-// If your compiler has builtin support for any of the following
-// traits concepts, then redefine the appropriate macros to pick
-// up on the compiler support:
-//
-// (these should largely ignore cv-qualifiers)
-// BOOST_IS_CLASS(T) should evaluate to true if T is a class or struct type
-// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type
-// BOOST_IS_UNION(T) should evaluate to true if T is a union type
-// BOOST_IS_POD(T) should evaluate to true if T is a POD type
-// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union
-// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
-// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
-// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
-// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
-
-#define BOOST_IS_CLASS(T) false
-#define BOOST_IS_ENUM(T) false
-#define BOOST_IS_UNION(T) false
-#define BOOST_IS_POD(T) false
-#define BOOST_IS_EMPTY(T) false
-#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
-#define BOOST_HAS_TRIVIAL_COPY(T) false
-#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
-#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
-
-
-namespace boost{
-//
-// forward declare all type traits templates here
-//
-// conversion_traits.hpp:
-template <class From, class To>
-struct is_convertible;
-// alignment_traits.hpp:
-template <class T>
-struct alignment_of;
-// arithmetic_traits.hpp:
-template <class T>
-struct is_void;
-template <class T>
-struct is_integral;
-template <class T>
-struct is_float;
-template <class T>
-struct is_arithmetic;
-template <class T>
-struct is_fundamental;
-
-// cv_traits.hpp:
-template <class T>
-struct is_const;
-template <class T>
-struct is_volatile;
-template <class T>
-struct remove_const;
-template <class T>
-struct remove_volatile;
-template <class T>
-struct remove_cv;
-
-// composite_traits.hpp:
-template <class T>
-struct is_array;
-template <class T>
-struct is_pointer;
-template <class T>
-struct is_reference;
-template <class T>
-struct is_member_pointer;
-template <class T>
-struct is_enum;
-template <class T>
-struct is_union;
-
-// object_traits.hpp:
-template <class T>
-struct is_object;
-template <class T>
-struct is_scalar;
-template <class T>
-struct is_class;
-template <class T>
-struct is_compound;
-template <class T>
-struct is_POD;
-template <class T>
-struct has_trivial_constructor;
-template <class T>
-struct has_trivial_copy;
-template <class T>
-struct has_trivial_assign;
-template <class T>
-struct has_trivial_destructor;
-template <class T>
-struct is_empty;
-
-// transform_traits.hpp:
-template <class T>
-struct remove_reference;
-template <class T>
-struct add_reference;
-template <class T>
-struct remove_bounds;
-template <class T>
-struct remove_pointer;
-template <class T>
-struct add_pointer;
-
-// same_traits.hpp:
-template <class T, class U>
-struct is_same;
-
-} // namespace boost
-
-#endif // BOOST_FWD_TYPE_TRAITS_HPP
-
-
-
-
--- a/development/include/boost/type_traits/ice.hpp
+++ b/development/include/boost/type_traits/ice.hpp
@ -1,76 +0,0 @@
-
-//  (C) Copyright John Maddock and Steve Cleary 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  macros and helpers for working with integral-constant-expressions.
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#define BOOST_ICE_TYPE_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-#define BOOST_DECL_MC(type, name, value) enum{name = value }
-#define BOOST_DECL_MC2(type, name, v1, v2) enum{name = v1,v2 }
-#else
-#define BOOST_DECL_MC(type, name, value) static const type name = value
-#define BOOST_DECL_MC2(type, name, v1, v2) static const type name = v1,v2
-#endif
-
-
-namespace boost{
-namespace type_traits{
-
-typedef char yes_type;
-typedef double no_type;
-
-template <bool b>
-struct ice_not
-{ BOOST_DECL_MC(bool, value, true); };
-template <>
-struct ice_not<true>
-{ BOOST_DECL_MC(bool, value, false); };
-
-template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
-struct ice_or;
-template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
-struct ice_or
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-template <>
-struct ice_or<false, false, false, false, false, false, false>
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-
-template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
-struct ice_and;
-template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
-struct ice_and
-{
-   BOOST_DECL_MC(bool, value, false);
-};
-template <>
-struct ice_and<true, true, true, true, true, true, true>
-{
-   BOOST_DECL_MC(bool, value, true);
-};
-
-
-} // namespace type_traits
-
-} // namespace boost
-
-#endif // BOOST_ICE_TYPE_TRAITS_HPP
-
-
-
-
--- a/development/include/boost/type_traits/object_traits.hpp
+++ b/development/include/boost/type_traits/object_traits.hpp
@ -1,318 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines object traits classes:
-//  is_object, is_scalar, is_class, is_compound, is_POD, 
-//  has_trivial_constructor, has_trivial_copy, has_trivial_assign, 
-//  has_trivial_destructor, is_empty.
-//
-
-#ifndef OBJECT_TYPE_TRAITS_HPP
-#define OBJECT_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef COMPOSITE_TYPE_TRAITS_HPP
-#include <boost/type_traits/composite_traits.hpp>
-#endif
-#ifndef ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-
-namespace boost{
-
-/**********************************************
- *
- * is_object
- *
- **********************************************/
-template <typename T>
-struct is_object
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         !::boost::is_reference<T>::value,
-         !::boost::is_void<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * is_scalar
- *
- **********************************************/
-template <typename T>
-struct is_scalar
-{ 
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::is_arithmetic<T>::value,
-         ::boost::is_enum<T>::value,
-         ::boost::is_pointer<T>::value,
-         ::boost::is_member_pointer<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * is_class
- *
- **********************************************/
-template <typename T>
-struct is_class
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         !::boost::is_union<T>::value,
-         !::boost::is_scalar<T>::value,
-         !::boost::is_array<T>::value,
-         !::boost::is_reference<T>::value,
-         !::boost::is_void<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * is_compound
- *
- **********************************************/
-template <typename T> struct is_compound
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::is_array<T>::value,
-         ::boost::is_pointer<T>::value,
-         ::boost::is_reference<T>::value,
-         ::boost::is_class<T>::value,
-         ::boost::is_union<T>::value,
-         ::boost::is_enum<T>::value,
-         ::boost::is_member_pointer<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * is_POD
- *
- **********************************************/
-template <typename T> struct is_POD
-{ 
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::is_scalar<T>::value,
-         ::boost::is_void<T>::value,
-         BOOST_IS_POD(T)
-      >::value));
-};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T, std::size_t sz>
-struct is_POD<T[sz]>
-{
-   BOOST_DECL_MC(bool, value, ::boost::is_POD<T>::value);
-};
-#endif
-
-/**********************************************
- *
- * has_trivial_constructor
- *
- **********************************************/
-template <typename T>
-struct has_trivial_constructor
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::is_POD<T>::value,
-         BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
-      >::value));
-};
-
-/**********************************************
- *
- * has_trivial_copy
- *
- **********************************************/
-template <typename T>
-struct has_trivial_copy
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         ::boost::type_traits::ice_or<
-            ::boost::is_POD<T>::value,
-            BOOST_HAS_TRIVIAL_COPY(T)
-         >::value,
-      !::boost::is_volatile<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * has_trivial_assign
- *
- **********************************************/
-template <typename T>
-struct has_trivial_assign
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         ::boost::type_traits::ice_or<
-            ::boost::is_POD<T>::value,
-            BOOST_HAS_TRIVIAL_ASSIGN(T)
-         >::value,
-      !::boost::is_const<T>::value,
-      !::boost::is_volatile<T>::value
-      >::value));
-};
-
-/**********************************************
- *
- * has_trivial_destructor
- *
- **********************************************/
-template <typename T>
-struct has_trivial_destructor
-{
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::is_POD<T>::value,
-         BOOST_HAS_TRIVIAL_DESTRUCTOR(T)
-      >::value));
-};
-
-/**********************************************
- *
- * is_empty
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
-#ifdef __MWERKS__
-   empty_helper_t1();  // hh compiler bug workaround
-#endif
-   int i[256];
-};
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T, bool b, bool b2>
-struct empty_helper{ BOOST_DECL_MC(bool, value, false); };
-
-template <typename T>
-struct empty_helper<T, true, false>
-{
-   BOOST_DECL_MC(bool, value,
-      (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)));
-};
-}
-
-template <typename T>
-struct is_empty
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_or<
-         ::boost::detail::empty_helper<T,
-            ::boost::is_class<T>::value ,
-            ::boost::is_convertible<T,int>::value
-         >::value,
-         BOOST_IS_EMPTY(cvt)
-      >::value));
-};
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-
-namespace detail{
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
-   int i[256];
-};
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T>
-struct empty_helper_base
-{
-   enum{ value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)) };
-};
-
-template <typename T>
-struct empty_helper_nonbase
-{
-   enum{ value = false };
-};
-
-template <bool base>
-struct empty_helper_chooser
-{
-   template <class T>
-   struct rebind
-   {
-      typedef empty_helper_nonbase<T> type;
-   };
-};
-
-template <>
-struct empty_helper_chooser<true>
-{
-   template <class T>
-   struct rebind
-   {
-      typedef empty_helper_base<T> type;
-   };
-};
-
-} // namespace detail
-
-template <typename T> 
-struct is_empty
-{ 
-private:
-   typedef ::boost::detail::empty_helper_chooser<
-      ::boost::type_traits::ice_and<
-         !::boost::is_convertible<T,int>::value,
-         !::boost::is_convertible<T,double>::value,
-         !::boost::is_pointer<T>::value,
-         !::boost::is_member_pointer<T>::value,
-         !::boost::is_array<T>::value,
-         !::boost::is_void<T>::value,
-         !::boost::is_convertible<T, const volatile void*>::value
-      >::value> chooser;
-   typedef typename chooser::template rebind<T> bound_type;
-   typedef typename bound_type::type eh_type;
-public:
-   BOOST_DECL_MC(bool, value, 
-      (::boost::type_traits::ice_or<eh_type::value, BOOST_IS_EMPTY(T)>::value)); 
-};
-
-#else
-template <typename T> struct is_empty
-{ enum{ value = BOOST_IS_EMPTY(T) }; };
-#endif  // defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-} // namespace boost
-
-#endif // OBJECT_TYPE_TRAITS_HPP
-
-
-
-
-
-
--- a/development/include/boost/type_traits/same_traits.hpp
+++ b/development/include/boost/type_traits/same_traits.hpp
@ -1,90 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines is_same:
-
-#ifndef SAME_TRAITS_HPP
-#define SAME_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#if !defined(COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
-#include <boost/type_traits/composite_traits.hpp>
-#endif
-
-namespace boost{
-
-/**********************************************
- *
- * is_same
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <typename T, typename U>
-struct is_same
-{ BOOST_DECL_MC(bool, value, false); };
-
-template <typename T>
-struct is_same<T, T>
-{ BOOST_DECL_MC(bool, value, true); };
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#ifdef BOOST_MSVC
-
-namespace detail{
-
-template<class T1>
-struct is_same_part_1 {
-  template<class T2>  struct part_2     { enum { value = false }; };
-  template<>          struct part_2<T1> { enum { value = true }; };
-};
-
-} // namespace detail
-
-template<class T1, class T2>
-struct is_same : detail::is_same_part_1<T1>::template part_2<T2> {};
-
-#else // BOOST_MSVC
-
-namespace detail{
-   template <class T>
-   ::boost::type_traits::yes_type is_same_helper(T*, T*);
-   ::boost::type_traits::no_type is_same_helper(...);
-}
-
-template <typename T, typename U>
-struct is_same
-{
-private:
-   static T t;
-   static U u;
-public:
-   BOOST_DECL_MC(bool, value,
-      (::boost::type_traits::ice_and<
-         (sizeof(type_traits::yes_type) == sizeof(detail::is_same_helper(&t,&u))),
-         (::boost::is_reference<T>::value == ::boost::is_reference<U>::value),
-         (sizeof(T) == sizeof(U))
-        >::value));
-};
-
-#endif // BOOST_MSVC
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-} // namespace boost
-
-#endif  // SAME_TRAITS_HPP
- 
-
-
--- a/development/include/boost/type_traits/transform_traits.hpp
+++ b/development/include/boost/type_traits/transform_traits.hpp
@ -1,187 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  defines traits classes for transforming one type to another:
-//  remove_reference, add_reference, remove_bounds, remove_pointer.
-//
-
-#ifndef TRANSFORM_TRAITS_HPP
-#define TRANSFORM_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#if !defined(COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/type_traits/composite_traits.hpp>
-#endif
-
-namespace boost{
-
-/**********************************************
- *
- * remove_reference
- *
- **********************************************/
-template <typename T>
-struct remove_reference
-{ typedef T type; };
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct remove_reference<T&>
-{ typedef T type; };
-#endif
-#if defined(__BORLANDC__) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T>
-struct remove_reference<T&const>
-{ typedef T type; };
-template <typename T>
-struct remove_reference<T&volatile>
-{ typedef T type; };
-template <typename T>
-struct remove_reference<T&const volatile>
-{ typedef T type; };
-#endif
-
-/**********************************************
- *
- * add_reference
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct add_reference
-{ typedef T& type; };
-template <typename T>
-struct add_reference<T&>
-{ typedef T& type; };
-#elif defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-namespace detail{
-
-template <bool>
-struct reference_adder
-{
-   template <class T>
-   struct rebind
-   {
-      typedef T& type;
-   };
-};
-
-template <>
-struct reference_adder<true>
-{
-   template <class T>
-   struct rebind
-   {
-      typedef T type;
-   };
-};
-
-} // namespace detail
-
-template <typename T>
-struct add_reference
-{
-private:
-   typedef typename detail::reference_adder< ::boost::is_reference<T>::value>::template rebind<T> binder;
-public:
-   typedef typename binder::type type;
-};
-
-#else
-template <typename T>
-struct add_reference
-{ typedef T& type; };
-#endif
-
-/**********************************************
- *
- * remove_bounds
- *
- **********************************************/
-template <typename T>
-struct remove_bounds
-{ typedef T type; };
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T, std::size_t N>
-struct remove_bounds<T[N]>
-{ typedef T type; };
-template <typename T, std::size_t N>
-struct remove_bounds<const T[N]>
-{ typedef const T type; };
-template <typename T, std::size_t N>
-struct remove_bounds<volatile T[N]>
-{ typedef volatile T type; };
-template <typename T, std::size_t N>
-struct remove_bounds<const volatile T[N]>
-{ typedef const volatile T type; };
-#endif
-
-/**********************************************
- *
- * remove_pointer
- *
- **********************************************/
-template <typename T>
-struct remove_pointer
-{ typedef T type; };
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct remove_pointer<T*>
-{ typedef T type; };
-template <typename T>
-struct remove_pointer<T*const>
-{ typedef T type; };
-template <typename T>
-struct remove_pointer<T*volatile>
-{ typedef T type; };
-template <typename T>
-struct remove_pointer<T*const volatile>
-{ typedef T type; };
-#endif
-
-/**********************************************
- *
- * add_pointer
- *
- **********************************************/
-template <typename T>
-struct add_pointer
-{
-private:
-   typedef typename remove_reference<T>::type no_ref_type;
-   typedef typename remove_bounds<no_ref_type>::type no_b_type;
-public:
-   typedef no_b_type* type;
-};
-
-} // namespace boost
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// if there is no partial specialisation support
-// include a bunch of full specialisations as a workaround:
-//
-#include <boost/type_traits/transform_traits_spec.hpp>
-#else
-#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
-#endif
-
-#endif // TRANSFORM_TRAITS_HPP
- 
-
-
-
-
--- a/development/include/boost/type_traits/transform_traits_spec.hpp
+++ b/development/include/boost/type_traits/transform_traits_spec.hpp
@ -1,74 +0,0 @@
-
-// Copyright (c) 2001 Aleksey Gurtovoy.
-// Permission to copy, use, modify, sell and distribute this software is 
-// granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-#ifndef BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
-#define BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
-
-#ifndef TRANSFORM_TRAITS_HPP
-#include <boost/type_traits/transform_traits.hpp>
-#endif
-
-#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T)           \
-template<> struct remove_const<T const>             { typedef T type; };          \
-template<> struct remove_const<T const volatile>    { typedef T volatile type; }; \
-template<> struct remove_volatile<T volatile>       { typedef T type; };          \
-template<> struct remove_volatile<T const volatile> { typedef T const type; };    \
-template<> struct remove_cv<T const>                { typedef T type; };          \
-template<> struct remove_cv<T volatile>             { typedef T type; };          \
-template<> struct remove_cv<T const volatile>       { typedef T type; };          \
-/**/
-
-#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T)             \
-template<> struct remove_pointer<T*>          { typedef T type; };            \
-template<> struct remove_reference<T&>        { typedef T type; };            \
-/**/
-
-#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T)             \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T)                     \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const)               \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T volatile)            \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const volatile)      \
-/**/
-
-#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T)                 \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T)                     \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T)               \
-/**/
-
-#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T)                 \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T*)                        \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const*)                  \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T volatile*)               \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const volatile*)         \
-/**/
-
-#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T)                   \
-namespace boost {                                                             \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T)                         \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T)                         \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T*)                        \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const*)                  \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T volatile*)               \
-BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const volatile*)         \
-}                                                                             \
-/**/
-
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(char)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed   char)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned char)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed   short)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned short)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed   int)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned int)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed   long)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned long)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(float)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(double)
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(long double)
-
-#endif // BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
-
--- a/development/include/boost/type_traits/type_traits_test.hpp
+++ b/development/include/boost/type_traits/type_traits_test.hpp
@ -1,361 +0,0 @@
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears   
-//  in all copies. This software is provided "as is" without express or implied   
-//  warranty, and with no claim as to its suitability for any purpose.   
-
-//  common test code for type-traits tests
-//  WARNING: contains code as well as declarations!
-
-
-#ifndef BOOST_TYPE_TRAITS_TEST_HPP
-#define BOOST_TYPE_TRAITS_TEST_HPP
-#include <iostream>
-#include <typeinfo>
-//
-// define tests here
-unsigned failures = 0;
-unsigned test_count = 0;
-//
-// This must get defined within the test file.
-// All compilers have bugs, set this to the number of
-// regressions *expected* from a given compiler,
-// if there are no workarounds for the bugs, *and*
-// the regressions have been investigated.
-//
-extern unsigned int expected_failures;
-//
-// proc check_result()
-// Checks that there were no regressions:
-//
-int check_result(int argc, char** argv)
-{
-   std::cout << test_count << " tests completed, "
-      << failures << " failures found, "
-      << expected_failures << " failures expected from this compiler." << std::endl;
-   if((argc == 2) 
-   	&& (argv[1][0] == '-')
-   	&& (argv[1][1] == 'a')
-   	&& (argv[1][2] == 0))
-   {
-      std::cout << "Press any key to continue...";
-      std::cin.get();
-   }
-   return (failures == expected_failures) ? 0 : failures;
-}
-
-
-//
-// this one is to verify that a constant is indeed a
-// constant-integral-expression:
-//
-template <bool>
-struct checker
-{
-   static void check(bool, bool, const char*, bool){ ++test_count; }
-};
-
-template <>
-struct checker<false>
-{
-   static void check(bool o, bool n, const char* name, bool soft)
-   {
-      ++test_count;
-      ++failures;
-      // if this is a soft test, then failure is expected,
-      // or may depend upon factors outside our control
-      // (like compiler options)...
-      if(soft)++expected_failures;
-      std::cout << "checking value of " << name << "...failed" << std::endl;
-      std::cout << "\tfound: " << n << " expected " << o << std::endl;
-   }
-};
-
-template <class T, class U>
-struct type_checker
-{
-   static void check(const char* TT, const char* TU, const char* expression)
-   {
-      ++test_count;
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-      if((typeid(T) != typeid(U))
-         || (::boost::is_reference<T>::value != ::boost::is_reference<U>::value)
-         || (::boost::is_const<T>::value != ::boost::is_const<U>::value)
-         || (::boost::is_volatile<T>::value != ::boost::is_volatile<U>::value))
-      {
-#endif
-         ++failures;
-         std::cout << "checking type of " << expression << "...failed" << std::endl;
-         std::cout << "   expected type was " << TT << std::endl;
-         std::cout << "   typeid(" << TT << ") was: " << typeid(T).name() << std::endl;
-         std::cout << "   typeid(" << TU << ") was: " << typeid(U).name() << std::endl;
-         std::cout << "   In template class " << typeid(type_checker<T,U>).name() << std::endl;
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-      }
-#endif
-   }
-};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct type_checker<T,T>
-{
-   static void check(const char*, const char*, const char*)
-   {
-      ++test_count;
-   }
-};
-#endif
-
-
-#define value_test(v, x) checker<(v == x)>::check(v, x, #x, false);
-#define soft_value_test(v, x) checker<(v == x)>::check(v, x, #x, true);
-
-#define value_fail(v, x) \
-      ++test_count; \
-      ++failures; \
-      std::cout << "checking value of " << #x << "...failed" << std::endl; \
-      std::cout << "   " #x " does not compile on this compiler" << std::endl;
-
-
-#define type_test(v, x) type_checker<v,x>::check(#v, #x, #x);
-#define type_test3(v, x, z) type_checker<v,x,z>::check(#v, #x "," #z, #x "," #z);
-#ifndef SHORT_TRANSFORM_TEST
-#define transform_check(name, from_suffix, to_suffix)\
-   type_test(bool to_suffix, name<bool from_suffix>::type);\
-   type_test(char to_suffix, name<char from_suffix>::type);\
-   type_test(wchar_t to_suffix, name<wchar_t from_suffix>::type);\
-   type_test(signed char to_suffix, name<signed char from_suffix>::type);\
-   type_test(unsigned char to_suffix, name<unsigned char from_suffix>::type);\
-   type_test(short to_suffix, name<short from_suffix>::type);\
-   type_test(unsigned short to_suffix, name<unsigned short from_suffix>::type);\
-   type_test(int to_suffix, name<int from_suffix>::type);\
-   type_test(unsigned int to_suffix, name<unsigned int from_suffix>::type);\
-   type_test(long to_suffix, name<long from_suffix>::type);\
-   type_test(unsigned long to_suffix, name<unsigned long from_suffix>::type);\
-   type_test(float to_suffix, name<float from_suffix>::type);\
-   type_test(long double to_suffix, name<long double from_suffix>::type);\
-   type_test(double to_suffix, name<double from_suffix>::type);\
-   type_test(UDT to_suffix, name<UDT from_suffix>::type);\
-   type_test(enum1 to_suffix, name<enum1 from_suffix>::type);
-#else
-#define transform_check(name, from_suffix, to_suffix)\
-   type_test(int to_suffix, name<int from_suffix>::type);\
-   type_test(UDT to_suffix, name<UDT from_suffix>::type);\
-   type_test(enum1 to_suffix, name<enum1 from_suffix>::type);
-#endif
-
-#define boost_dummy_macro_param
-
-template <class T>
-struct test_align
-{
-   struct padded
-   {
-      char c;
-      T t;
-   };
-   static void do_it()
-   {
-      padded p;
-      unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
-      ++test_count;
-      // only fail if we do not have a multiple of the actual value:
-      if((a > ::boost::alignment_of<T>::value) || (a % ::boost::alignment_of<T>::value))
-      {
-         ++failures;
-         std::cout << "checking value of " << typeid(boost::alignment_of<T>).name() << "...failed" << std::endl;
-         std::cout << "\tfound: " << boost::alignment_of<T>::value << " expected " << a << std::endl;
-      }
-      // suppress warnings about unused variables:
-      (void)p;
-      (void)a;
-   }
-};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct test_align<T&>
-{
-   static void do_it()
-   {
-      //
-      // we can't do the usual test because we can't take the address
-      // of a reference, so check that the result is the same as for a
-      // pointer type instead:
-      unsigned a = boost::alignment_of<T*>::value;
-      ++test_count;
-      if(a != boost::alignment_of<T&>::value)
-      {
-         ++failures;
-         std::cout << "checking value of " << typeid(boost::alignment_of<T&>).name() << "...failed" << std::endl;
-         std::cout << "\tfound: " << boost::alignment_of<T&>::value << " expected " << a << std::endl;
-      }
-   }
-};
-#endif
-
-#define align_test(T) test_align<T>::do_it()
-
-//
-// the following code allows us to test that a particular
-// template functions correctly when instanciated inside another template
-// (some bugs only show up in that situation).  For each template
-// we declare one NESTED_DECL(classname) that sets up the template class
-// and multiple NESTED_TEST(classname, template-arg) declarations, to carry
-// the actual tests:
-template <bool b>
-struct nested_test
-{
-   typedef nested_test type;
-   bool run_time_value;
-   const char* what;
-   nested_test(bool b2, const char* w) : run_time_value(b2), what(w) { check(); }
-   void check()
-   {
-      ++test_count;
-      if(b != run_time_value)
-      {
-         ++failures;
-         std::cerr << "Mismatch between runtime and compile time values in " << what << std::endl;
-      }
-   }
-};
-
-#define NESTED_DECL(what)\
-template <class T> \
-struct BOOST_TT_JOIN(nested_tester_,what){\
-   nested_test< (0 != ::boost::what<T>::value)> tester;\
-   BOOST_TT_JOIN(nested_tester_,what)(const char* s) : tester(::boost::what<T>::value, s){}\
-};
-#define NESTED_TEST(what, with)\
-{BOOST_TT_JOIN(nested_tester_,what)<with> check(#what "<" #with ">"); (void)check;}
-
-#define BOOST_TT_JOIN( X, Y ) BOOST_DO_TT_JOIN( X, Y )
-#define BOOST_DO_TT_JOIN( X, Y ) X##Y
-
-
-
-//
-// define some types to test with:
-//
-enum enum_UDT{ one, two, three };
-struct UDT
-{
-   UDT(){};
-   ~UDT(){};
-   UDT(const UDT&);
-   UDT& operator=(const UDT&);
-   int i;
-
-   void f1();
-   int f2();
-   int f3(int);
-   int f4(int, float);
-};
-
-typedef void(*f1)();
-typedef int(*f2)(int);
-typedef int(*f3)(int, bool);
-typedef void (UDT::*mf1)();
-typedef int (UDT::*mf2)();
-typedef int (UDT::*mf3)(int);
-typedef int (UDT::*mf4)(int, float);
-typedef int (UDT::*mp);
-
-// cv-qualifiers applied to reference types should have no effect
-// declare these here for later use with is_reference and remove_reference:
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-typedef int& r_type;
-typedef const r_type cr_type;
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-
-struct POD_UDT { int x; };
-struct empty_UDT{ ~empty_UDT(){}; };
-struct empty_POD_UDT{};
-union union_UDT
-{
-  int x;
-  double y;
-  ~union_UDT();
-};
-union POD_union_UDT
-{
-  int x;
-  double y;
-};
-union empty_union_UDT
-{
-  ~empty_union_UDT();
-};
-union empty_POD_union_UDT{};
-
-class Base { };
-
-class Deriverd : public Base { };
-
-class NonDerived { };
-
-enum enum1
-{
-   one_,two_
-};
-
-enum enum2
-{
-   three_,four_
-};
-
-struct VB
-{
-   virtual ~VB(){};
-};
-
-struct VD : VB
-{
-   ~VD(){};
-};
-//
-// struct non_pointer:
-// used to verify that is_pointer does not return
-// true for class types that implement operator void*()
-//
-struct non_pointer
-{
-   operator void*(){return this;}
-};
-struct non_int_pointer
-{
-   int i;
-   operator int*(){return &i;}
-};
-struct int_constructible
-{
-   int_constructible(int);
-};
-struct int_convertible
-{
-   operator int();
-};
-//
-// struct non_empty:
-// used to verify that is_empty does not emit
-// spurious warnings or errors.
-//
-struct non_empty : boost::noncopyable
-{
-   int i;
-};
-
-
-
-#endif // BOOST_TYPE_TRAITS_TEST_HPP
-
-
-
-
-
-
--- a/development/include/boost/utility.hpp
+++ b/development/include/boost/utility.hpp
@ -1,96 +0,0 @@
-//  boost utility.hpp header file  -------------------------------------------//
-
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies. This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Classes appear in alphabetical order
-
-//  Revision History
-//  26 Jan 00  protected noncopyable destructor added (Miki Jovanovic)
-//  10 Dec 99  next() and prior() templates added (Dave Abrahams)
-//  30 Aug 99  moved cast templates to cast.hpp (Beman Dawes)
-//   3 Aug 99  cast templates added
-//  20 Jul 99  name changed to utility.hpp 
-//   9 Jun 99  protected noncopyable default ctor
-//   2 Jun 99  Initial Version. Class noncopyable only contents (Dave Abrahams)
-
-#ifndef BOOST_UTILITY_HPP
-#define BOOST_UTILITY_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>            // for size_t
-#include <utility>            // for std::pair
-
-namespace boost
-{
-
-//  next() and prior() template functions  -----------------------------------//
-
-    //  Helper functions for classes like bidirectional iterators not supporting
-    //  operator+ and operator-.
-    //
-    //  Usage:
-    //    const std::list<T>::iterator p = get_some_iterator();
-    //    const std::list<T>::iterator prev = boost::prior(p);
-
-    //  Contributed by Dave Abrahams
-
-    template <class T>
-    T next(T x) { return ++x; }
-
-    template <class T>
-    T prior(T x) { return --x; }
-
-
-//  class noncopyable  -------------------------------------------------------//
-
-    //  Private copy constructor and copy assignment ensure classes derived from
-    //  class noncopyable cannot be copied.
-
-    //  Contributed by Dave Abrahams
-
-    class noncopyable
-    {
-    protected:
-        noncopyable(){}
-        ~noncopyable(){}
-    private:  // emphasize the following members are private
-        noncopyable( const noncopyable& );
-        const noncopyable& operator=( const noncopyable& );
-    }; // noncopyable
-
-//  class tied  -------------------------------------------------------//
-
-    // A helper for conveniently assigning the two values from a pair
-    // into separate variables. The idea for this comes from Jaakko J<>rvi's
-    // Binder/Lambda Library.
-
-    // Constributed by Jeremy Siek
-
-    template <class A, class B>
-    class tied {
-    public:
-      inline tied(A& a, B& b) : _a(a), _b(b) { }
-      template <class U, class V>
-      inline tied& operator=(const std::pair<U,V>& p) {
-        _a = p.first;
-        _b = p.second;
-        return *this;
-      }
-    protected:
-      A& _a;
-      B& _b;
-    };
-
-    template <class A, class B>
-    inline tied<A,B> tie(A& a, B& b) { return tied<A,B>(a, b); }
-
-} // namespace boost
-
-#endif  // BOOST_UTILITY_HPP
-
--- a/development/index.htm
+++ b/development/index.htm
--- a/development/is_convertible_test.cpp
+++ b/development/is_convertible_test.cpp
@ -1,72 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/utility.hpp>
-#include "boost/type_traits/type_traits_test.hpp"
-
-
-int main(int argc, char* argv[])
-{
-   value_test(true, (boost::is_convertible<Deriverd,Base>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Base,Base>::value));
-   value_test(false, (boost::is_convertible<Base,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
-   value_test(false, (boost::is_convertible<NonDerived,Base>::value));
-   value_test(false, (boost::is_convertible<boost::noncopyable, int>::value));
-   value_test(true, (boost::is_convertible<float,int>::value));
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   value_test(false, (boost::is_convertible<float,void>::value));
-   value_test(false, (boost::is_convertible<void,float>::value));
-   value_test(true, (boost::is_convertible<void,void>::value));
-#endif
-   value_test(true, (boost::is_convertible<enum1, int>::value));
-   value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
-   value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
-   value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
-   value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
-   value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
-   value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
-   value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
-   value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
-
-   value_test(false, (boost::is_convertible<const int *, int*>::value));
-   value_test(false, (boost::is_convertible<const int&, int&>::value));
-   value_test(true, (boost::is_convertible<int*, int[2]>::value));
-   value_test(false, (boost::is_convertible<const int*, int[3]>::value));
-   value_test(true, (boost::is_convertible<const int&, int>::value));
-   value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
-   value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
-   value_test(true, (boost::is_convertible<int *, const int*>::value));
-   value_test(true, (boost::is_convertible<int&, const int&>::value));
-   value_test(true, (boost::is_convertible<int[2], int*>::value));
-   value_test(true, (boost::is_convertible<int[2], const int*>::value));
-   value_test(false, (boost::is_convertible<const int[2], int*>::value));
-
-   value_test(true, (boost::is_convertible<non_pointer, void*>::value));
-   value_test(false, (boost::is_convertible<non_pointer, int*>::value));
-   value_test(true, (boost::is_convertible<non_int_pointer, int*>::value));
-   value_test(true, (boost::is_convertible<non_int_pointer, void*>::value));
-   value_test(true, (boost::is_convertible<int, int_constructible>::value));
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef __BORLANDC__
-unsigned int expected_failures = 1;
-#else
-unsigned int expected_failures = 0;
-#endif
-
-
-
-
-
-
-
--- a/development/is_same_test.cpp
+++ b/development/is_same_test.cpp
@ -1,42 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/same_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-int main(int argc, char* argv[])
-{
-   value_test(true, (::boost::is_same<int, int>::value))
-   value_test(false, (::boost::is_same<int, const int>::value))
-   value_test(false, (::boost::is_same<int, int&>::value))
-   value_test(false, (::boost::is_same<const int, int&>::value))
-   value_test(false, (::boost::is_same<int, const int&>::value))
-   value_test(false, (::boost::is_same<int*, const int*>::value))
-   value_test(false, (::boost::is_same<int*, int*const>::value))
-   value_test(false, (::boost::is_same<int, int[2]>::value))
-   value_test(false, (::boost::is_same<int*, int[2]>::value))
-   value_test(false, (::boost::is_same<int[4], int[2]>::value))
-   value_test(false, (::boost::is_same<void, int>::value))
-   value_test(true, (::boost::is_same<void, void>::value))
-   value_test(false, (::boost::is_same<void, const void>::value))
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef BOOST_MSVC
-// can't separate void and cv-void:
-unsigned int expected_failures = 1;
-#else
-unsigned int expected_failures = 0;
-#endif
-
--- a/development/iter_swap_example.cpp
+++ b/development/iter_swap_example.cpp
@ -1,110 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
- *                  in which case it uses a "safe" approach, otherwise calls swap
- *                  on the assumption that swap may be specialised for the pointed-to type.
- *
- */
-
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include <iterator>
-#include <vector>
-#include <memory>
-
-#include <boost/type_traits.hpp>
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-namespace opt{
-
-//
-// iter_swap:
-// tests whether iterator is a proxying iterator or not, and
-// uses optimal form accordingly:
-//
-namespace detail{
-
-template <bool b>
-struct swapper
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      typedef typename std::iterator_traits<I>::value_type v_t;
-      v_t v = *one;
-      *one = *two;
-      *two = v;
-   }
-};
-
-#ifdef __GNUC__
-using std::swap;
-#endif
-
-template <>
-struct swapper<true>
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      using std::swap;
-      swap(*one, *two);
-   }
-};
-
-}
-
-template <typename I1, typename I2>
-inline void iter_swap(I1 one, I2 two)
-{
-   typedef typename std::iterator_traits<I1>::reference r1_t;
-   typedef typename std::iterator_traits<I2>::reference r2_t;
-   detail::swapper<
-      ::boost::type_traits::ice_and<
-         ::boost::is_reference<r1_t>::value, 
-         ::boost::is_reference<r2_t>::value,
-         ::boost::is_same<r1_t, r2_t>::value
-      >::value>::do_swap(one, two);
-}
-
-
-};   // namespace opt
-
-int main()
-{
-   //
-   // testing iter_swap
-   // really just a check that it does in fact compile...
-   std::vector<int> v1;
-   v1.push_back(0);
-   v1.push_back(1);
-   std::vector<bool> v2;
-   v2.push_back(0);
-   v2.push_back(1);
-   opt::iter_swap(v1.begin(), v1.begin()+1);
-   opt::iter_swap(v2.begin(), v2.begin()+1);
-
-   cout << "Press any key to exit...";
-   cin.get();
-}
-
-
--- a/development/linux-regression.out.txt
+++ b/development/linux-regression.out.txt
@ -1,580 +0,0 @@
-*** libs/type_traits/alignment_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/alignment_test.cpp
-./boosttmp.exe
-13 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/alignment_test.cpp
-./boosttmp.exe
-13 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/alignment_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-./boosttmp.exe
-checking value of boost::alignment_of<double>...failed
-	found: 4 expected 8
-13 tests completed, 1 failures found, 0 failures expected from this compiler.
-Fail
-
-*** libs/type_traits/arithmetic_traits_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
-./boosttmp.exe
-111 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
-./boosttmp.exe
-111 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-./boosttmp.exe
-111 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/composite_traits_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/composite_traits_test.cpp
-./boosttmp.exe
-checking value of boost::is_reference<cr_type>::value...failed
-	found: 0 expected 1
-65 tests completed, 1 failures found, 1 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/composite_traits_test.cpp
-./boosttmp.exe
-checking value of boost::is_reference<cr_type>::value...failed
-	found: 0 expected 1
-65 tests completed, 1 failures found, 1 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/composite_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file composite_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/composite_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file composite_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/composite_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file composite_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file composite_traits_test.o
-./boosttmp.exe
-65 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/cv_traits_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/cv_traits_test.cpp
-./boosttmp.exe
-18 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/cv_traits_test.cpp
-./boosttmp.exe
-18 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/cv_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file cv_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/cv_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file cv_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/cv_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file cv_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file cv_traits_test.o
-./boosttmp.exe
-18 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/is_convertible_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_convertible_test.cpp
-./boosttmp.exe
-37 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_convertible_test.cpp
-./boosttmp.exe
-37 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/is_convertible_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file is_convertible_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_convertible_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file is_convertible_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_convertible_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file is_convertible_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file is_convertible_test.o
-./boosttmp.exe
-37 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/is_same_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_same_test.cpp
-./boosttmp.exe
-10 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_same_test.cpp
-./boosttmp.exe
-10 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/is_same_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file is_same_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_same_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file is_same_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_same_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file is_same_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file is_same_test.o
-./boosttmp.exe
-10 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/object_type_traits_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/object_type_traits_test.cpp
-./boosttmp.exe
-checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_copy<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_assign<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::is_empty<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::is_empty<empty_POD_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::is_empty<empty_union_UDT>::value...failed
-   boost::is_empty<empty_union_UDT>::value does not compile on this compiler
-checking value of boost::is_empty<boost::noncopyable>::value...failed
-	found: 0 expected 1
-122 tests completed, 7 failures found, 7 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/object_type_traits_test.cpp
-./boosttmp.exe
-checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_copy<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_assign<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::is_empty<empty_union_UDT>::value...failed
-   boost::is_empty<empty_union_UDT>::value does not compile on this compiler
-122 tests completed, 4 failures found, 7 failures expected from this compiler.
-Fail
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/object_type_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-./boosttmp.exe
-checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_copy<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::has_trivial_assign<empty_UDT>::value...failed
-	found: 0 expected 1
-checking value of boost::is_empty<empty_union_UDT>::value...failed
-   boost::is_empty<empty_union_UDT>::value does not compile on this compiler
-122 tests completed, 4 failures found, 0 failures expected from this compiler.
-Fail
-
-*** libs/type_traits/transform_traits_test.cpp ***
-
-** GCC 2.95.2
-g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/transform_traits_test.cpp
-./boosttmp.exe
-checking type of boost::remove_reference<cr_type>::type...failed
-   expected type was int
-   typeid(int) was: i
-   typeid(boost::remove_reference<cr_type>::type) was: i
-   In template class t12type_checker2ZiZCRi
-39 tests completed, 1 failures found, 1 failures expected from this compiler.
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/transform_traits_test.cpp
-./boosttmp.exe
-checking type of boost::remove_reference<cr_type>::type...failed
-   expected type was int
-   typeid(int) was: i
-   typeid(boost::remove_reference<cr_type>::type) was: i
-   In template class t12type_checker2ZiZCRi
-39 tests completed, 1 failures found, 1 failures expected from this compiler.
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -o boosttmp.exe -I../.. ../../libs/type_traits/transform_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file transform_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/transform_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file transform_traits_test.o
-C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/transform_traits_test.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
-          qualifiers are meaningless in this declaration
-  typedef const r_type cr_type;
-          ^
-
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file transform_traits_test.o
-C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file transform_traits_test.o
-./boosttmp.exe
-39 tests completed, 0 failures found, 0 failures expected from this compiler.
-Pass
-
-*** libs/type_traits/trivial_destructor_example.cpp ***
-
-** GCC 2.95.2
-g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -c -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-"../../libs/type_traits/trivial_destructor_example.cpp", line 99: warning: 
-          variable "ci_array" was declared but never referenced
-  const int ci_array[array_size] = {0,};
-            ^
-
-"../../libs/type_traits/trivial_destructor_example.cpp", line 101: warning: 
-          variable "cc_array" was declared but never referenced
-  const char cc_array[array_size] = { 0,};
-             ^
-
-Pass
-
-*** libs/type_traits/copy_example.cpp ***
-
-** GCC 2.95.2
-g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/copy_example.cpp
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/copy_example.cpp
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -c -I../.. ../../libs/type_traits/copy_example.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-Pass
-
-*** libs/type_traits/fill_example.cpp ***
-
-** GCC 2.95.2
-g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/fill_example.cpp
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/fill_example.cpp
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -c -I../.. ../../libs/type_traits/fill_example.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-Pass
-
-*** libs/type_traits/iter_swap_example.cpp ***
-
-** GCC 2.95.2
-g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/iter_swap_example.cpp
-Pass
-
-** GCC 2.95.2 STLport 4.0
-g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/iter_swap_example.cpp
-Pass
-
-** Comeau C++ 4.2.44 beta3
-como -c -I../.. ../../libs/type_traits/iter_swap_example.cpp
-Comeau C/C++ 4.2.44 (Aug  2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
-Copyright 1988-2000 Comeau Computing.  All rights reserved.
-MODE:non-strict C++
-
-Pass
-
--- a/development/object_type_traits_test.cpp
+++ b/development/object_type_traits_test.cpp
@ -1,191 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/object_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-NESTED_DECL(is_class)
-NESTED_DECL(is_object)
-NESTED_DECL(is_scalar)
-NESTED_DECL(is_compound)
-NESTED_DECL(is_POD)
-
-int main(int argc, char* argv[])
-{
-   NESTED_TEST(is_class, int)
-   NESTED_TEST(is_class, UDT)
-   NESTED_TEST(is_object, int)
-   NESTED_TEST(is_object, void)
-   NESTED_TEST(is_object, UDT)
-   NESTED_TEST(is_scalar, void)
-   NESTED_TEST(is_scalar, int)
-   NESTED_TEST(is_compound, int)
-   NESTED_TEST(is_compound, UDT)
-   NESTED_TEST(is_POD, int)
-   NESTED_TEST(is_POD, UDT)
-
-   value_test(false, boost::is_class<int>::value)
-   value_test(false, boost::is_class<const int>::value)
-   value_test(false, boost::is_class<volatile int>::value)
-   value_test(false, boost::is_class<int*>::value)
-   value_test(false, boost::is_class<int* const>::value)
-   value_test(false, boost::is_class<int[2]>::value)
-   value_test(false, boost::is_class<int&>::value)
-   value_test(false, boost::is_class<mf4>::value)
-   value_test(false, boost::is_class<f1>::value)
-   value_test(false, boost::is_class<enum_UDT>::value)
-   value_test(true, boost::is_class<UDT>::value)
-   value_test(true, boost::is_class<UDT const>::value)
-   value_test(true, boost::is_class<UDT volatile>::value)
-   value_test(true, boost::is_class<empty_UDT>::value)
-   value_test(true, boost::is_class<std::iostream>::value)
-   value_test(false, boost::is_class<UDT*>::value)
-   value_test(false, boost::is_class<UDT[2]>::value)
-   value_test(false, boost::is_class<UDT&>::value)
-   value_test(false, boost::is_class<void>::value)
-
-   value_test(true, boost::is_object<int>::value)
-   value_test(true, boost::is_object<UDT>::value)
-   value_test(false, boost::is_object<int&>::value)
-   value_test(false, boost::is_object<void>::value)
-
-   value_test(true, boost::is_scalar<int>::value)
-   value_test(true, boost::is_scalar<void*>::value)
-   value_test(false, boost::is_scalar<void>::value)
-   value_test(false, boost::is_scalar<UDT>::value)
-   value_test(false, boost::is_scalar<int&>::value)
-
-   value_test(true, boost::is_compound<UDT>::value)
-   value_test(true, boost::is_compound<void*>::value)
-   value_test(false, boost::is_compound<void>::value)
-   value_test(false, boost::is_compound<int>::value)
-
-   value_test(true, boost::is_POD<int>::value)
-   value_test(true, boost::is_POD<int*>::value)
-   value_test(false, boost::is_POD<int&>::value)
-   value_test(true, boost::is_POD<int*const>::value)
-   value_test(true, boost::is_POD<const int>::value)
-   value_test(true, boost::is_POD<volatile int>::value)
-   value_test(false, boost::is_POD<const int&>::value)
-   value_test(true, boost::is_POD<int[2]>::value)
-   value_test(true, boost::is_POD<int[3][2]>::value)
-   value_test(true, boost::is_POD<int[2][4][5][6][3]>::value)
-   value_test(true, boost::is_POD<f1>::value)
-   value_test(true, boost::is_POD<mf2>::value)
-   value_test(false, boost::is_POD<UDT>::value)
-   value_test(false, boost::is_POD<empty_UDT>::value)
-   value_test(true, boost::is_POD<enum_UDT>::value)
-   value_test(true, boost::is_POD<void>::value)
-
-   value_test(true, boost::has_trivial_constructor<int>::value)
-   value_test(true, boost::has_trivial_constructor<int*>::value)
-   value_test(true, boost::has_trivial_constructor<int*const>::value)
-   value_test(true, boost::has_trivial_constructor<const int>::value)
-   value_test(true, boost::has_trivial_constructor<volatile int>::value)
-   value_test(true, boost::has_trivial_constructor<int[2]>::value)
-   value_test(true, boost::has_trivial_constructor<int[3][2]>::value)
-   value_test(true, boost::has_trivial_constructor<int[2][4][5][6][3]>::value)
-   value_test(true, boost::has_trivial_constructor<f1>::value)
-   value_test(true, boost::has_trivial_constructor<mf2>::value)
-   value_test(false, boost::has_trivial_constructor<UDT>::value)
-   value_test(true, boost::has_trivial_constructor<empty_UDT>::value)
-   value_test(true, boost::has_trivial_constructor<enum_UDT>::value)
-   value_test(true, boost::has_trivial_constructor<void>::value)
-
-   value_test(true, boost::has_trivial_copy<int>::value)
-   value_test(true, boost::has_trivial_copy<int*>::value)
-   value_test(true, boost::has_trivial_copy<int*const>::value)
-   value_test(true, boost::has_trivial_copy<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(false, boost::has_trivial_copy<volatile int>::value)
-   value_test(true, boost::has_trivial_copy<int[2]>::value)
-   value_test(true, boost::has_trivial_copy<int[3][2]>::value)
-   value_test(true, boost::has_trivial_copy<int[2][4][5][6][3]>::value)
-   value_test(true, boost::has_trivial_copy<f1>::value)
-   value_test(true, boost::has_trivial_copy<mf2>::value)
-   value_test(false, boost::has_trivial_copy<UDT>::value)
-   value_test(true, boost::has_trivial_copy<empty_UDT>::value)
-   value_test(true, boost::has_trivial_copy<enum_UDT>::value)
-   value_test(true, boost::has_trivial_copy<void>::value)
-
-   value_test(true, boost::has_trivial_assign<int>::value)
-   value_test(true, boost::has_trivial_assign<int*>::value)
-   value_test(false, boost::has_trivial_assign<int*const>::value)
-   value_test(false, boost::has_trivial_assign<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(false, boost::has_trivial_assign<volatile int>::value)
-   value_test(true, boost::has_trivial_assign<int[2]>::value)
-   value_test(true, boost::has_trivial_assign<int[3][2]>::value)
-   value_test(true, boost::has_trivial_assign<int[2][4][5][6][3]>::value)
-   value_test(true, boost::has_trivial_assign<f1>::value)
-   value_test(true, boost::has_trivial_assign<mf2>::value)
-   value_test(false, boost::has_trivial_assign<UDT>::value)
-   value_test(true, boost::has_trivial_assign<empty_UDT>::value)
-   value_test(true, boost::has_trivial_assign<enum_UDT>::value)
-   value_test(true, boost::has_trivial_assign<void>::value)
-
-   value_test(true, boost::has_trivial_destructor<int>::value)
-   value_test(true, boost::has_trivial_destructor<int*>::value)
-   value_test(true, boost::has_trivial_destructor<int*const>::value)
-   value_test(true, boost::has_trivial_destructor<const int>::value)
-   value_test(true, boost::has_trivial_destructor<volatile int>::value)
-   value_test(true, boost::has_trivial_destructor<int[2]>::value)
-   value_test(true, boost::has_trivial_destructor<int[3][2]>::value)
-   value_test(true, boost::has_trivial_destructor<int[2][4][5][6][3]>::value)
-   value_test(true, boost::has_trivial_destructor<f1>::value)
-   value_test(true, boost::has_trivial_destructor<mf2>::value)
-   value_test(false, boost::has_trivial_destructor<UDT>::value)
-   value_test(false, boost::has_trivial_destructor<empty_UDT>::value)
-   value_test(true, boost::has_trivial_destructor<enum_UDT>::value)
-   value_test(true, boost::has_trivial_destructor<void>::value)
-
-   soft_value_test(false, boost::is_empty<int>::value)
-   soft_value_test(false, boost::is_empty<int*>::value)
-   soft_value_test(false, boost::is_empty<int&>::value)
-   soft_value_test(false, boost::is_empty<void>::value)
-#if defined(__MWERKS__)
-   // apparent compiler bug causes this to fail to compile:
-   value_fail(false, boost::is_empty<int[2]>::value)
-#else
-   soft_value_test(false, boost::is_empty<int[2]>::value)
-#endif
-   soft_value_test(false, boost::is_empty<f1>::value)
-   soft_value_test(false, boost::is_empty<mf1>::value)
-   soft_value_test(false, boost::is_empty<UDT>::value)
-   soft_value_test(true, boost::is_empty<empty_UDT>::value)
-   soft_value_test(true, boost::is_empty<empty_POD_UDT>::value)
-   // this one will not compile on most compilers,
-   // because we can't tell the difference between
-   // unions and classes:
-   value_fail(true, boost::is_empty<empty_union_UDT>::value)
-   soft_value_test(false, boost::is_empty<enum_UDT>::value)
-   soft_value_test(true, boost::is_empty<boost::noncopyable>::value)
-   soft_value_test(false, boost::is_empty<non_empty>::value)
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef __BORLANDC__
-// can't handle enum's or classes that are POD's
-unsigned int expected_failures = 10;
-#elif defined(__GNUC__)
-// classes that are POD's, or empty:
-unsigned int expected_failures = 4;
-#elif defined(BOOST_MSVC)
-// can't handle classes that are POD's or arrays that are POD's
-unsigned int expected_failures = 19;
-#else
-unsigned int expected_failures = 4;
-#endif
-
-
--- a/development/regress.cfg
+++ b/development/regress.cfg
@ -1,14 +0,0 @@
-run libs/type_traits/alignment_test.cpp
-run libs/type_traits/arithmetic_traits_test.cpp
-run libs/type_traits/composite_traits_test.cpp
-run libs/type_traits/cv_traits_test.cpp
-run libs/type_traits/is_convertible_test.cpp
-run libs/type_traits/is_same_test.cpp
-run libs/type_traits/object_type_traits_test.cpp
-run libs/type_traits/transform_traits_test.cpp
-compile libs/type_traits/trivial_destructor_example.cpp
-compile libs/type_traits/copy_example.cpp
-compile libs/type_traits/fill_example.cpp
-compile libs/type_traits/iter_swap_example.cpp
-
-
--- a/development/regression.out.txt
+++ b/development/regression.out.txt
--- a/development/transform_traits_test.cpp
+++ b/development/transform_traits_test.cpp
@ -1,395 +0,0 @@
-
-//  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/type_traits/transform_traits.hpp>
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/utility.hpp>
-
-#ifdef __BORLANDC__
-#pragma hrdstop
-#endif
-
-//
-// some of these tests, particularly those involving
-// the use of the transform_check macro are tantamount
-// to "compiler-abuse", and actually hide a *lot* of
-// template test code.  To prevent "Internal Compiler Error"
-// type messages, we have to split these up into lots of
-// separate functions:
-#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && (__BORLANDC__ < 0x550))
-#define SHORT_TRANSFORM_TEST
-#endif
-#include "boost/type_traits/type_traits_test.hpp"
-
-#define BOOST_DECL_TRANSFORM_TEST(name, type, from, to)\
-void name(){ transform_check(type, from, to) }
-#define BOOST_DECL_TRANSFORM_TEST3(name, type, from)\
-void name(){ transform_check(type, from, boost_dummy_macro_param) }
-#define BOOST_DECL_TRANSFORM_TEST2(name, type)\
-void name(){ transform_check(type, boost_dummy_macro_param, boost_dummy_macro_param) }
-
-/***********************************************************************
- *
- * tests for remove_const:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST3(remove_const_test_1, ::boost::remove_const, const)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_2, ::boost::remove_const, volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_3, ::boost::remove_const, const volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST2(remove_const_test_4, ::boost::remove_const)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_6, ::boost::remove_const, *const, *)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_7, ::boost::remove_const, *volatile, *volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_8, ::boost::remove_const, *const volatile, *volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_9, ::boost::remove_const, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_11, ::boost::remove_const, volatile*, volatile*)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_12, ::boost::remove_const, const[2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_13, ::boost::remove_const, volatile[2], volatile[2])
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_14, ::boost::remove_const, const volatile[2], volatile[2])
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_15, ::boost::remove_const, [2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_16, ::boost::remove_const, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_const_test_17, ::boost::remove_const, const*const, const*)
-
-void check_remove_const()
-{
-   remove_const_test_1();
-   remove_const_test_2();
-   remove_const_test_3();
-   remove_const_test_4();
-   remove_const_test_6();
-   remove_const_test_7();
-   remove_const_test_8();
-   remove_const_test_9();
-   remove_const_test_11();
-   remove_const_test_12();
-   remove_const_test_13();
-   remove_const_test_14();
-   remove_const_test_15();
-   remove_const_test_16();
-   remove_const_test_17();
-}
-
-/***********************************************************************
- *
- * tests for remove_volatile:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_1, ::boost::remove_volatile, const, const)
-BOOST_DECL_TRANSFORM_TEST3(remove_volatile_test_2, ::boost::remove_volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_3, ::boost::remove_volatile, const volatile, const)
-BOOST_DECL_TRANSFORM_TEST2(remove_volatile_test_4, ::boost::remove_volatile)
-BOOST_DECL_TRANSFORM_TEST2(remove_volatile_test_5, ::boost::remove_volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_6, ::boost::remove_volatile, *const, *const)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_7, ::boost::remove_volatile, *volatile, *)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_8, ::boost::remove_volatile, *const volatile, *const)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_9, ::boost::remove_volatile, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_10, ::boost::remove_volatile, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_11, ::boost::remove_volatile, volatile*, volatile*)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_12, ::boost::remove_volatile, const[2], const[2])
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_13, ::boost::remove_volatile, volatile[2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_14, ::boost::remove_volatile, const volatile[2], const[2])
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_15, ::boost::remove_volatile, [2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_16, ::boost::remove_volatile, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_17, ::boost::remove_volatile, const*volatile, const*)
-
-void check_remove_volatile()
-{
-   remove_volatile_test_1();
-   remove_volatile_test_2();
-   remove_volatile_test_3();
-   remove_volatile_test_4();
-   remove_volatile_test_5();
-   remove_volatile_test_6();
-   remove_volatile_test_7();
-   remove_volatile_test_8();
-   remove_volatile_test_9();
-   remove_volatile_test_10();
-   remove_volatile_test_11();
-   remove_volatile_test_12();
-   remove_volatile_test_13();
-   remove_volatile_test_14();
-   remove_volatile_test_15();
-   remove_volatile_test_16();
-   remove_volatile_test_17();
-}
-
-/***********************************************************************
- *
- * tests for remove_cv:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_1, ::boost::remove_cv, const)
-BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_2, ::boost::remove_cv, volatile)
-BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_3, ::boost::remove_cv, const volatile)
-BOOST_DECL_TRANSFORM_TEST2(remove_cv_test_4, ::boost::remove_cv)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_5, ::boost::remove_cv, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_6, ::boost::remove_cv, *const, *)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_7, ::boost::remove_cv, *volatile, *)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_8, ::boost::remove_cv, *const volatile, *)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_9, ::boost::remove_cv, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_10, ::boost::remove_cv, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_11, ::boost::remove_cv, volatile*, volatile*)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_12, ::boost::remove_cv, const[2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_13, ::boost::remove_cv, volatile[2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_14, ::boost::remove_cv, const volatile[2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_15, ::boost::remove_cv, [2], [2])
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_16, ::boost::remove_cv, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_cv_test_17, ::boost::remove_cv, const*volatile, const*)
-
-void check_remove_cv()
-{
-   remove_cv_test_1();
-   remove_cv_test_2();
-   remove_cv_test_3();
-   remove_cv_test_4();
-   remove_cv_test_5();
-   remove_cv_test_6();
-   remove_cv_test_7();
-   remove_cv_test_8();
-   remove_cv_test_9();
-   remove_cv_test_10();
-   remove_cv_test_11();
-   remove_cv_test_12();
-   remove_cv_test_13();
-   remove_cv_test_14();
-   remove_cv_test_15();
-   remove_cv_test_16();
-   remove_cv_test_17();
-}
-
-/***********************************************************************
- *
- * tests for remove_reference:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_1, ::boost::remove_reference, const, const)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_2, ::boost::remove_reference, volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_3, ::boost::remove_reference, &)
-BOOST_DECL_TRANSFORM_TEST2(remove_reference_test_4, ::boost::remove_reference)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_5, ::boost::remove_reference, const &, const)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_6, ::boost::remove_reference, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_7, ::boost::remove_reference, *volatile, *volatile)
-BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_8, ::boost::remove_reference, &)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_9, ::boost::remove_reference, const &, const)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_10, ::boost::remove_reference, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_11, ::boost::remove_reference, volatile*, volatile*)
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_12, ::boost::remove_reference, const[2], const[2])
-BOOST_DECL_TRANSFORM_TEST(remove_reference_test_13, ::boost::remove_reference, (&)[2], [2])
-
-void check_remove_reference()
-{
-   remove_reference_test_1();
-   remove_reference_test_2();
-   remove_reference_test_3();
-   remove_reference_test_4();
-   remove_reference_test_5();
-   remove_reference_test_6();
-   remove_reference_test_7();
-   remove_reference_test_8();
-   remove_reference_test_9();
-   remove_reference_test_10();
-   remove_reference_test_11();
-   remove_reference_test_12();
-   remove_reference_test_13();
-}
-
-/***********************************************************************
- *
- * tests for remove_bounds:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_1, ::boost::remove_bounds, const, const)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_2, ::boost::remove_bounds, volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST3(remove_bounds_test_3, ::boost::remove_bounds, [2])
-BOOST_DECL_TRANSFORM_TEST2(remove_bounds_test_4, ::boost::remove_bounds)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_5, ::boost::remove_bounds, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_6, ::boost::remove_bounds, *, *)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_7, ::boost::remove_bounds, *volatile, *volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_8, ::boost::remove_bounds, const [2], const)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_9, ::boost::remove_bounds, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_10, ::boost::remove_bounds, const*, const*)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_11, ::boost::remove_bounds, volatile*, volatile*)
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_12, ::boost::remove_bounds, const[2][3], const[3])
-BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_13, ::boost::remove_bounds, (&)[2], (&)[2])
-
-void check_remove_bounds()
-{
-   remove_bounds_test_1();
-   remove_bounds_test_2();
-   remove_bounds_test_3();
-   remove_bounds_test_4();
-   remove_bounds_test_5();
-   remove_bounds_test_6();
-   remove_bounds_test_7();
-   remove_bounds_test_8();
-   remove_bounds_test_9();
-   remove_bounds_test_10();
-   remove_bounds_test_11();
-   remove_bounds_test_12();
-   remove_bounds_test_13();
-}
-
-/***********************************************************************
- *
- * tests for remove_pointer:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_1, ::boost::remove_pointer, const, const)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_2, ::boost::remove_pointer, volatile, volatile)
-BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_3, ::boost::remove_pointer, *)
-BOOST_DECL_TRANSFORM_TEST2(remove_pointer_test_4, ::boost::remove_pointer)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_5, ::boost::remove_pointer, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_6, ::boost::remove_pointer, &, &)
-BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_7, ::boost::remove_pointer, *volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_8, ::boost::remove_pointer, const [2], const[2])
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_9, ::boost::remove_pointer, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_10, ::boost::remove_pointer, const*, const)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_11, ::boost::remove_pointer, volatile*, volatile)
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_12, ::boost::remove_pointer, const[2][3], const[2][3])
-BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_13, ::boost::remove_pointer, (&)[2], (&)[2])
-
-void check_remove_pointer()
-{
-   remove_pointer_test_1();
-   remove_pointer_test_2();
-   remove_pointer_test_3();
-   remove_pointer_test_4();
-   remove_pointer_test_5();
-   remove_pointer_test_6();
-   remove_pointer_test_7();
-   remove_pointer_test_8();
-   remove_pointer_test_9();
-   remove_pointer_test_10();
-   remove_pointer_test_11();
-   remove_pointer_test_12();
-   remove_pointer_test_13();
-}
-
-/***********************************************************************
- *
- * tests for add_reference:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_1, ::boost::add_reference, const, const&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_2, ::boost::add_reference, volatile, volatile&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_3, ::boost::add_reference, *, *&)
-//BOOST_DECL_TRANSFORM_TEST2(add_reference_test_4, ::boost::add_reference)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_5, ::boost::add_reference, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_6, ::boost::add_reference, &, &)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_7, ::boost::add_reference, *volatile, *volatile&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_8, ::boost::add_reference, const [2], const (&)[2])
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_9, ::boost::add_reference, const &, const&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_10, ::boost::add_reference, const*, const*&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_11, ::boost::add_reference, volatile*, volatile*&)
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_12, ::boost::add_reference, const[2][3], const (&)[2][3])
-BOOST_DECL_TRANSFORM_TEST(add_reference_test_13, ::boost::add_reference, (&)[2], (&)[2])
-
-void check_add_reference()
-{
-   add_reference_test_1();
-   add_reference_test_2();
-   add_reference_test_3();
-   //add_reference_test_4();
-   add_reference_test_5();
-   add_reference_test_6();
-   add_reference_test_7();
-   add_reference_test_8();
-   add_reference_test_9();
-   add_reference_test_10();
-   add_reference_test_11();
-   add_reference_test_12();
-   add_reference_test_13();
-}
-
-/***********************************************************************
- *
- * tests for add_pointer:
- *
- **********************************************************************/
-
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_1, ::boost::add_pointer, const, const*)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_2, ::boost::add_pointer, volatile, volatile*)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_3, ::boost::add_pointer, *, **)
-//BOOST_DECL_TRANSFORM_TEST2(add_pointer_test_4, ::boost::add_pointer)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_7, ::boost::add_pointer, *volatile, *volatile*)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_10, ::boost::add_pointer, const*, const**)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_11, ::boost::add_pointer, volatile*, volatile**)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_5, ::boost::add_pointer, const &, const*)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_6, ::boost::add_pointer, &, *)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_8, ::boost::add_pointer, const [2], const *)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_9, ::boost::add_pointer, const &, const*)
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_12, ::boost::add_pointer, const[2][3], const (*)[3])
-BOOST_DECL_TRANSFORM_TEST(add_pointer_test_13, ::boost::add_pointer, (&)[2], *)
-#endif
-
-void check_add_pointer()
-{
-   add_pointer_test_1();
-   add_pointer_test_2();
-   add_pointer_test_3();
-   //add_pointer_test_4();
-   add_pointer_test_7();
-   add_pointer_test_10();
-   add_pointer_test_11();
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   add_pointer_test_5();
-   add_pointer_test_6();
-   add_pointer_test_8();
-   add_pointer_test_9();
-   add_pointer_test_12();
-   add_pointer_test_13();
-#endif
-}
-
-
-int main(int argc, char* argv[])
-{
-   check_remove_const();
-   check_remove_volatile();
-   check_remove_cv();
-   check_remove_reference();
-   check_remove_bounds();
-   check_remove_pointer();
-   check_add_reference();
-   check_add_pointer();
-
-   type_test(void, boost::remove_const<void>::type)
-   type_test(void, boost::remove_volatile<void>::type)
-   type_test(void, boost::remove_cv<void>::type)
-
-   type_test(int, boost::remove_reference<cr_type>::type)
-   type_test(void, boost::remove_reference<void>::type)
-
-   type_test(void, boost::remove_bounds<void>::type)
-   type_test(void, boost::remove_pointer<void>::type)
-
-   return check_result(argc, argv);
-}
-
-//
-// define the number of failures expected for given compilers:
-#ifdef __BORLANDC__
-#ifdef SHORT_TRANSFORM_TEST
-unsigned int expected_failures = 97; // cv-qualifiers
-#else
-unsigned int expected_failures = 422; // cv-qualifiers
-#endif
-#elif defined(__GNUC__)
-unsigned int expected_failures = 1; // cv-qualified references
-#else
-unsigned int expected_failures = 0;
-#endif
-
-
-
-
--- a/development/trivial_destructor_example.cpp
+++ b/development/trivial_destructor_example.cpp
@ -1,166 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::destroy_array - an example of optimisation based upon omitted destructor calls
- *
- */
-
-
-#include <iostream>
-
-#include <boost/timer.hpp>
-#include <boost/type_traits.hpp>
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-namespace opt{
-
-//
-// algorithm destroy_array:
-// The reverse of std::unitialized_copy, takes a block of
-// initialized memory and calls destructors on all objects therein.
-//
-
-namespace detail{
-
-template <bool>
-struct array_destroyer
-{
-   template <class T>
-   static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
-};
-
-template <>
-struct array_destroyer<true>
-{
-   template <class T>
-   static void destroy_array(T*, T*){}
-};
-
-template <class T>
-void do_destroy_array(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-
-}; // namespace detail
-
-template <class T>
-inline void destroy_array(T* p1, T* p2)
-{
-   detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
-}
-
-//
-// unoptimised versions of destroy_array:
-//
-template <class T>
-void destroy_array1(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-template <class T>
-void destroy_array2(T* first, T* last)
-{
-   for(; first != last; ++first) first->~T();
-}
-
-} // namespace opt
-
-//
-// define some global data:
-//
-const int array_size = 1000;
-int i_array[array_size] = {0,};
-const int ci_array[array_size] = {0,};
-char c_array[array_size] = {0,};
-const char cc_array[array_size] = { 0,};
-
-const int iter_count = 1000000;
-
-
-int main()
-{
-   boost::timer t;
-   double result;
-   int i;
-   //
-   // test destroy_array,
-   // compare destruction time of an array of ints
-   // with unoptimised form.
-   //
-   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
-   cout << "testing destroy_array...\n"
-    "[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
-   
-   // cache load:
-   opt::destroy_array(i_array, i_array + array_size);
-
-   // time optimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>: " << result << endl;
-
-   // cache load:
-   opt::destroy_array1(i_array, i_array + array_size);
-
-   // time unoptimised version #1:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array1(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#1): " << result << endl;
-
-   // cache load:
-   opt::destroy_array2(i_array, i_array + array_size);
-
-   // time unoptimised version #2:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array2(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
-
-   return 0;
-}
-
-
-
-
-
-
-
-
-
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,19 @@
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+using quickbook ;
+
+xml type_traits : type_traits.qbk ;
+boostbook standalone
+    :
+        type_traits
+    :
+        <xsl:param>nav.layout=none
+        <xsl:param>navig.graphics=0
+    ;
+
+install html : ../../../doc/html/boostbook.css ;
+install ../ : ../../../boost.png ;
+
--- a/doc/type_traits.qbk
+++ b/doc/type_traits.qbk
--- a/examples/copy_example.cpp
+++ b/examples/copy_example.cpp
@ -1,16 +1,10 @@

 /*
 *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
+ * (C) Copyright John Maddock 1999-2005. 
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 * This file provides some example of type_traits usage -
 * by "optimising" various algorithms:
@ -25,9 +19,9 @@
 #include <iterator>
 #include <memory>

+#include <boost/test/included/prg_exec_monitor.hpp>
 #include <boost/timer.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/test/cpp_main.cpp>

 using std::cout;
 using std::endl;
@ -43,8 +37,8 @@ namespace opt{

 namespace detail{

-template<typename I1, typename I2>
-I2 copy_imp(I1 first, I1 last, I2 out)
+template<typename I1, typename I2, bool b>
+I2 copy_imp(I1 first, I1 last, I2 out, const boost::integral_constant<bool, b>&)
 {
   while(first != last)
   {
@ -55,79 +49,28 @@ I2 copy_imp(I1 first, I1 last, I2 out)
   return out;
 }

-template <bool b>
-struct copier
-{
-   template<typename I1, typename I2>
-   static I2 do_copy(I1 first, I1 last, I2 out)
-   { return copy_imp(first, last, out); }
-};
-
-template <>
-struct copier<true>
-{
-   template<typename I1, typename I2>
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-
-}
-
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-
-template<typename I1, typename I2>
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
-   typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
-   return detail::copier<
-      ::boost::type_traits::ice_and<
-         ::boost::is_same<v1_t, v2_t>::value,
-         ::boost::is_pointer<I1>::value,
-         ::boost::is_pointer<I2>::value,
-         ::boost::has_trivial_assign<v1_t>::value
-      >::value>::do_copy(first, last, out);
-}
-
-#else // BOOST_NO_STD_ITERATOR_TRAITS
-
-//
-// If there is no standard iterator_traits then we have to
-// use overloading rather than iterator_traits to detect
-// when we have T*'s to copy.  Note that we cannot overload
-// copy directly as that will cause some standard conforming
-// code to fail to build:
-
-namespace detail{
-
-template<typename I1, typename I2>
-inline I2 copy_(const I1& first, const I1& last, const I2& out)
-{
-   return detail::copier<false>::do_copy(first, last, out);
-}
-
 template<typename T>
-inline T* copy_(const T*& first, const T*& last, T*& out)
+T* copy_imp(const T* first, const T* last, T* out, const boost::true_type&)
 {
-   return detail::copier< 
-      ::boost::has_trivial_assign<T>::value
-   >::do_copy(first, last, out);
+   memcpy(out, first, (last-first)*sizeof(T));
+   return out+(last-first);
 }

-} // namespace detail
+
+}

 template<typename I1, typename I2>
 inline I2 copy(I1 first, I1 last, I2 out)
 {
-   return detail::copy_(first, last, out);
+   //
+   // We can copy with memcpy if T has a trivial assignment operator,
+   // and if the iterator arguments are actually pointers (this last
+   // requirement we detect with overload resolution):
+   //
+   typedef typename std::iterator_traits<I1>::value_type value_type;
+   return detail::copy_imp(first, last, out, boost::has_trivial_assign<value_type>());
 }

-#endif // BOOST_NO_STD_ITERATOR_TRAITS
-
 };   // namespace opt

 //
@ -183,18 +126,6 @@ int cpp_main(int argc, char* argv[])
   result = t.elapsed();
   cout << "std::copy<const int*, int*>: " << result << endl;

-   // cache load:
-   opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
-
-   // time unoptimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
   // cache load:
   opt::copy(cc_array, cc_array + array_size, c_array);

@ -219,18 +150,6 @@ int cpp_main(int argc, char* argv[])
   result = t.elapsed();
   cout << "std::copy<const char*, char*>: " << result << endl;

-   // cache load:
-   opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
-
-   // time unoptimised version:
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
   return 0;
 }

@ -240,3 +159,4 @@ int cpp_main(int argc, char* argv[])



+
--- a/examples/fill_example.cpp
+++ b/examples/fill_example.cpp
@ -1,16 +1,10 @@

 /*
 *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
+ * (C) Copyright John Maddock 1999-2005. 
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 * This file provides some example of type_traits usage -
 * by "optimising" various algorithms:
@ -24,11 +18,11 @@
 #include <algorithm>
 #include <iterator>
 #include <memory>
+#include <cstring>

+#include <boost/test/included/prg_exec_monitor.hpp>
 #include <boost/timer.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/test/cpp_main.cpp>

 #if defined(BOOST_NO_STDC_NAMESPACE) || (defined(std) && defined(__SGI_STL_PORT))
 namespace std{ using :: memset; }
@ -41,13 +35,12 @@ using std::cin;
 namespace opt{
 //
 // fill
-// same as std::fill, uses memset where appropriate, along with call_traits
-// to "optimise" parameter passing.
+// same as std::fill, but uses memset where appropriate
 //
 namespace detail{

-template <typename I, typename T>
-void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
+template <typename I, typename T, bool b>
+void do_fill(I first, I last, const T& val, const boost::integral_constant<bool, b>&)
 {
   while(first != last)
   {
@ -56,43 +49,24 @@ void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
   }
 }

-template <bool opt>
-struct filler
+template <typename T>
+void do_fill(T* first, T* last, const T& val, const boost::true_type&)
 {
-   template <typename I, typename T>
-   struct rebind
-   {
-      static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
-      { do_fill_<I,T>(first, last, val); }
-   };
-};
-
-template <>
-struct filler<true>
-{
-   template <typename I, typename T>
-   struct rebind
-   {
-      static void do_fill(I first, I last, T val)
-      {
-         std::memset(first, val, last-first);
-      }
-   };
-};
+   std::memset(first, val, last-first);
+}

 }

 template <class I, class T>
 inline void fill(I first, I last, const T& val)
 {
-   typedef detail::filler<
-      ::boost::type_traits::ice_and<
-         ::boost::is_pointer<I>::value,
-         ::boost::is_arithmetic<T>::value,
-         (sizeof(T) == 1)
-      >::value> filler_t;
-   typedef typename filler_t:: template rebind<I,T> binder;
-   binder::do_fill(first, last, val);
+   //
+   // We can do an optimised fill if T has a trivial assignment 
+   // operator and if it's size is one:
+   //
+   typedef boost::integral_constant<bool, 
+      ::boost::has_trivial_assign<T>::value && (sizeof(T) == 1)> truth_type;
+   detail::do_fill(first, last, val, truth_type());
 }

 };   // namespace opt
@ -156,8 +130,7 @@ int cpp_main(int argc, char* argv[])
   result = t.elapsed();
   cout << "std::fill<char*, char>: " << result << endl << endl;

-   cout << "testing fill(int)...\n"
-   "[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
+   cout << "testing fill(int)...\n" << endl;

   // cache load:
   opt::fill(i_array, i_array + array_size, 3);
@ -190,3 +163,4 @@ int cpp_main(int argc, char* argv[])



+
--- a/examples/iter_swap_example.cpp
+++ b/examples/iter_swap_example.cpp
@ -1,16 +1,10 @@

 /*
 *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
+ * (C) Copyright John Maddock 1999-2005. 
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 * This file provides some example of type_traits usage -
 * by "optimising" various algorithms:
@ -28,8 +22,8 @@
 #include <vector>
 #include <memory>

+#include <boost/test/included/prg_exec_monitor.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/test/cpp_main.cpp>

 using std::cout;
 using std::endl;
@ -44,47 +38,39 @@ namespace opt{
 //
 namespace detail{

-template <bool b>
-struct swapper
+template <typename I>
+static void do_swap(I one, I two, const boost::false_type&)
 {
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      typedef typename std::iterator_traits<I>::value_type v_t;
-      v_t v = *one;
-      *one = *two;
-      *two = v;
-   }
-};
-
-#ifdef __GNUC__
-using std::swap;
-#endif
-
-template <>
-struct swapper<true>
+   typedef typename std::iterator_traits<I>::value_type v_t;
+   v_t v = *one;
+   *one = *two;
+   *two = v;
+}
+template <typename I>
+static void do_swap(I one, I two, const boost::true_type&)
 {
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      using std::swap;
-      swap(*one, *two);
-   }
-};
+   using std::swap;
+   swap(*one, *two);
+}

 }

 template <typename I1, typename I2>
 inline void iter_swap(I1 one, I2 two)
 {
+   //
+   // See is both arguments are non-proxying iterators, 
+   // and if both iterator the same type:
+   //
   typedef typename std::iterator_traits<I1>::reference r1_t;
   typedef typename std::iterator_traits<I2>::reference r2_t;
-   detail::swapper<
-      ::boost::type_traits::ice_and<
-         ::boost::is_reference<r1_t>::value, 
-         ::boost::is_reference<r2_t>::value,
-         ::boost::is_same<r1_t, r2_t>::value
-      >::value>::do_swap(one, two);
+
+   typedef boost::integral_constant<bool,
+      ::boost::is_reference<r1_t>::value
+      && ::boost::is_reference<r2_t>::value
+      && ::boost::is_same<r1_t, r2_t>::value> truth_type;
+
+   detail::do_swap(one, two, truth_type());
 }


@ -108,3 +94,4 @@ int cpp_main(int argc, char* argv[])
 }


+
--- a/examples/trivial_destructor_example.cpp
+++ b/examples/trivial_destructor_example.cpp
@ -1,16 +1,10 @@

 /*
 *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
+ * (C) Copyright John Maddock 1999-2005. 
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 * This file provides some example of type_traits usage -
 * by "optimising" various algorithms:
@ -21,10 +15,9 @@


 #include <iostream>
-
+#include <boost/test/included/prg_exec_monitor.hpp>
 #include <boost/timer.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/test/cpp_main.cpp>

 using std::cout;
 using std::endl;
@ -40,22 +33,8 @@ namespace opt{

 namespace detail{

-template <bool>
-struct array_destroyer
-{
-   template <class T>
-   static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
-};
-
-template <>
-struct array_destroyer<true>
-{
-   template <class T>
-   static void destroy_array(T*, T*){}
-};
-
 template <class T>
-void do_destroy_array(T* first, T* last)
+void do_destroy_array(T* first, T* last, const boost::false_type&)
 {
   while(first != last)
   {
@ -64,12 +43,17 @@ void do_destroy_array(T* first, T* last)
   }
 }

+template <class T>
+inline void do_destroy_array(T* first, T* last, const boost::true_type&)
+{
+}
+
 } // namespace detail

 template <class T>
 inline void destroy_array(T* p1, T* p2)
 {
-   detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
+   detail::do_destroy_array(p1, p2, ::boost::has_trivial_destructor<T>());
 }

 //
@ -166,3 +150,4 @@ int cpp_main(int argc, char* argv[])



+
--- a/include/boost/aligned_storage.hpp
+++ b/include/boost/aligned_storage.hpp
@ -0,0 +1,170 @@
+//-----------------------------------------------------------------------------
+// boost aligned_storage.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ALIGNED_STORAGE_HPP
+#define BOOST_ALIGNED_STORAGE_HPP
+
+#include <cstddef> // for std::size_t
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/type_traits/alignment_of.hpp"
+#include "boost/type_traits/type_with_alignment.hpp"
+#include "boost/type_traits/is_pod.hpp"
+
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/identity.hpp"
+
+#include "boost/type_traits/detail/bool_trait_def.hpp"
+
+namespace boost {
+
+namespace detail { namespace aligned_storage {
+
+BOOST_STATIC_CONSTANT(
+      std::size_t
+    , alignment_of_max_align = ::boost::alignment_of<max_align>::value
+    );
+
+//
+// To be TR1 conforming this must be a POD type:
+//
+template <
+      std::size_t size_
+    , std::size_t alignment_
+>
+struct aligned_storage_imp
+{
+    union data_t
+    {
+        char buf[size_];
+
+        typename mpl::eval_if_c<
+              alignment_ == std::size_t(-1)
+            , mpl::identity<detail::max_align>
+            , type_with_alignment<alignment_>
+            >::type align_;
+    } data_;
+};
+
+}} // namespace detail::aligned_storage
+
+template <
+      std::size_t size_
+    , std::size_t alignment_ = std::size_t(-1)
+>
+class aligned_storage
+{
+private: // representation
+
+   detail::aligned_storage::aligned_storage_imp<size_, alignment_> data_;
+
+public: // constants
+
+    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+
+    BOOST_STATIC_CONSTANT(
+          std::size_t
+        , size = size_
+        );
+    BOOST_STATIC_CONSTANT(
+          std::size_t
+        , alignment = (
+              alignment_ == std::size_t(-1)
+            ? ::boost::detail::aligned_storage::alignment_of_max_align
+            : alignment_
+            )
+        );
+
+#if defined(__GNUC__) &&\
+    (__GNUC__ >  3) ||\
+    (__GNUC__ == 3 && (__GNUC_MINOR__ >  2 ||\
+                      (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >=3)))
+
+private: // noncopyable
+
+    aligned_storage(const aligned_storage&);
+    aligned_storage& operator=(const aligned_storage&);
+
+#else // gcc less than 3.2.3
+
+public: // _should_ be noncopyable, but GCC compiler emits error
+
+    aligned_storage(const aligned_storage&);
+    aligned_storage& operator=(const aligned_storage&);
+
+#endif // gcc < 3.2.3 workaround
+
+public: // structors
+
+    aligned_storage()
+    {
+    }
+
+    ~aligned_storage()
+    {
+    }
+
+public: // accessors
+
+    void* address()
+    {
+        return this;
+    }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+    const void* address() const
+    {
+        return this;
+    }
+
+#else // MSVC6
+
+    const void* address() const;
+
+#endif // MSVC6 workaround
+
+};
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+// MSVC6 seems not to like inline functions with const void* returns, so we
+// declare the following here:
+
+template <std::size_t S, std::size_t A>
+const void* aligned_storage<S,A>::address() const
+{
+    return const_cast< aligned_storage<S,A>* >(this)->address();
+}
+
+#endif // MSVC6 workaround
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//
+// Make sure that is_pod recognises aligned_storage<>::type
+// as a POD (Note that aligned_storage<> itself is not a POD):
+//
+template <std::size_t size_, std::size_t alignment_>
+struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
+   BOOST_TT_AUX_BOOL_C_BASE(true)
+{ 
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true)
+}; 
+#endif
+
+
+} // namespace boost
+
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
+#endif // BOOST_ALIGNED_STORAGE_HPP
--- a/include/boost/detail/ob_type_traits.hpp
+++ b/include/boost/detail/ob_type_traits.hpp
@ -1,609 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  Crippled version of type traits for compilers that don't
-//  support partial specialisation. (C) John Maddock 2000
-
-/* Release notes:
-   20 Jan 2001:
-      Fixed is_same<T,U> so it would work with T == void or U == void
-      Suppressed some warnings in from_not_void_conversion<> for MSVC
-      Fixed a spelling error
-      (David Abrahams)
-	07 Oct 2000:
-		Added more fixes for is_array (based on a newgroup posting by Jonathan Lundquist).
-   03 Oct 2000:
-      Added more fixes to is_pointer and is_array (JM).
-   01st October 2000:
-      Fixed is_pointer, is_reference, is_const, is_volatile, is_same, is_member_pointer
-      using ideas suggested from "Generic<Programming>: Mappings between Types and Values" 
-      by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
-      Mat Marcus and Jesse Jones posted a version of is_pointer very similar to this one
-      on the boost list (Copyright 2000 Adobe Systems Incorporated and others. 
-      All rights reserved.).
-   31st July 2000:
-      Added is_convertible, alignment_of.
-   23rd July 2000:
-      Fixed is_void specialization. (JM)
-*/
-
-//
-// partial copyright for is_convertible:
-//
-// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu)
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy and use this software is granted,
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted,
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-#ifndef BOOST_OB_TYPE_TRAITS_HPP
-#define BOOST_OB_TYPE_TRAITS_HPP
-
-#include <boost/type.hpp>
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#error Internal header file: This header must be included by <boost/type_traits.hpp> only.
-#endif
-
-// **************************************************************************
-// Helper macros for builitin compiler support.
-// If your compiler has builtin support for any of the following
-// traits concepts, then redefine the appropriate macros to pick
-// up on the compiler support:
-
-#define BOOST_IS_CLASS(T) !is_union<T>::value & \
-    !is_scalar<T>::value & \
-    !is_array<T>::value & \
-    !is_reference<T>::value & \
-    !is_void<T>::value
-#define BOOST_IS_ENUM(T) false
-#define BOOST_IS_UNION(T) false
-#define BOOST_IS_POD(T) false
-#define BOOST_IS_EMPTY(T) false
-#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
-#define BOOST_HAS_TRIVIAL_COPY(T) false
-#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
-#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
-
-
-/**************************************************************************/
-
-namespace boost{
-//
-// start with fundamental type operations:
-// these don't actually work:
-//
-template <typename T>
-struct remove_volatile{ typedef T type; };
-template <typename T>
-struct remove_const{ typedef T type; };
-template <typename T>
-struct remove_cv{ typedef T type; };
-template <typename T> struct remove_reference{ typedef T type; };
-template <typename T> struct add_reference{ typedef T& type; };
-template <typename T> struct remove_bounds{ typedef T type; };
-
-/**************************************************************************/
-//
-// fundamental property classes:
-
-//* is a type T  declared const - is_const<T>
-namespace detail{
-   typedef char yes_result;
-   typedef char (&no_result)[8];
-   yes_result is_const_helper(const volatile void*);
-   no_result is_const_helper(volatile void *);
-   yes_result is_volatile_helper(const volatile void*);
-   no_result is_volatile_helper(const void *);
-}
-
-template <typename T>
-struct is_const
-{ 
-private:
-   static T t;
-public:
-   enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_const_helper(&t))) }; 
-};
-
-template <typename T>
-struct is_volatile
-{ 
-private:
-   static T t;
-public:
-   enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_volatile_helper(&t))) }; 
-};
-
-namespace detail{
-   template <class T>
-   yes_result is_same_helper(T*, T*);
-   no_result is_same_helper(...);
-
-   template <class T>
-   struct size_of
-   {
-       enum { value = sizeof(T) };
-   };
-
-   template <>
-   struct size_of<void>
-   {
-       enum { value = 0 };
-   };
-}
-
-template <typename T> struct is_reference;
-template <typename T, typename U> struct is_same
-{
-private:
-   static type<T> t;
-   static type<U> u;
-public:
-   enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_same_helper(&t,&u)))
-                 & (is_reference<T>::value == is_reference<U>::value)
-                 & (detail::size_of<T>::value == detail::size_of<U>::value) };
-};
-
-template <typename T> struct is_void{ enum{ value = false }; };
-template <> struct is_void<void>{ enum{ value = true }; };
-
-//* is a type T an unsigned integral type described in the standard (3.9.1p3)
-template <typename T> struct is_standard_unsigned_integral
-{ enum{ value = false}; };
-template <> struct is_standard_unsigned_integral<unsigned char>
-{ enum{ value = true}; };
-template <> struct is_standard_unsigned_integral<unsigned short>
-{ enum{ value = true}; };
-template <> struct is_standard_unsigned_integral<unsigned int>
-{ enum{ value = true}; };
-template <> struct is_standard_unsigned_integral<unsigned long>
-{ enum{ value = true}; };
-
-//* is a type T a signed integral type described in the standard (3.9.1p2)
-template <typename T> struct is_standard_signed_integral
-{ enum{ value = false}; };
-template <> struct is_standard_signed_integral<signed char>
-{ enum{ value = true}; };
-template <> struct is_standard_signed_integral<signed short>
-{ enum{ value = true}; };
-template <> struct is_standard_signed_integral<signed int>
-{ enum{ value = true}; };
-template <> struct is_standard_signed_integral<signed long>
-{ enum{ value = true}; };
-
-//* is a type T an integral type described in the standard (3.9.1p7)
-template <typename T> struct is_standard_integral
-{ enum{ value = is_standard_unsigned_integral<T>::value |
-is_standard_signed_integral<T>::value }; };
-template <> struct is_standard_integral<char>
-{ enum{ value = true}; };
-template <> struct is_standard_integral<wchar_t>
-{ enum{ value = true}; };
-template <> struct is_standard_integral<bool>
-{ enum{ value = true}; };
-
-//* is a type T a floating-point type described in the standard (3.9.1p8)
-template <typename T> struct is_standard_float
-{ enum{ value = false}; };
-template <> struct is_standard_float<float>
-{ enum{ value = true}; };
-template <> struct is_standard_float<double>
-{ enum{ value = true}; };
-template <> struct is_standard_float<long double>
-{ enum{ value = true}; };
-
-//* is a type T an arithmetic type described in the standard (3.9.1p8)
-template <typename T> struct is_standard_arithmetic
-{ enum{ value = is_standard_integral<T>::value | is_standard_float<T>::value}; };
-
-//* is a type T a fundamental type described in the standard (3.9.1)
-template <typename T> struct is_standard_fundamental
-{ enum{ value = is_standard_arithmetic<T>::value | is_void<T>::value}; };
-
-//* is a type T an unsigned integral type provided by a compiler extension
-// specialise for compiler defined extentions:
-template <typename T> struct is_extension_unsigned_integral
-{ enum{ value = false}; };
-
-//* is a type T a signed integral type provided by a compiler extension
-// specialise for compiler defined extentions:
-template <typename T> struct is_extension_signed_integral
-{ enum{ value = false}; };
-
-#ifdef ULLONG_MAX
-template <> struct is_extension_unsigned_integral<unsigned long long>
-{ enum{ value = true}; };
-template <> struct is_extension_signed_integral<long long>
-{ enum{ value = true}; };
-#endif
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_extension_unsigned_integral<unsigned __int64>
-{ enum{ value = true}; };
-template <> struct is_extension_signed_integral<__int64>
-{ enum{ value = true}; };
-#endif
-
-//* is a type T an integral type provided by a compiler extension
-template <typename T> struct is_extension_integral
-{ enum{ value = is_extension_signed_integral<T>::value |
-      is_extension_unsigned_integral<T>::value }; };
-
-//* is a type T a floating-point type provided by a compiler extension
-template <typename T> struct is_extension_float
-{ enum{ value = false}; };
-
-//* is a type T an arithmetic type provided by a compiler extension
-template <typename T> struct is_extension_arithmetic
-{ enum{ value = is_extension_integral<T>::value | is_extension_float<T>::value}; };
-
-//* is a type T a fundamental type provided by a compiler extension
-template <typename T> struct is_extension_fundamental
-{ enum{ value = is_extension_arithmetic<T>::value | is_void<T>::value}; };
-
-//* is a type T an unsigned integral type provided by the compiler or standard
-template <typename T> struct is_unsigned_integral
-{ enum{ value = is_standard_unsigned_integral<T>::value | is_extension_unsigned_integral<T>::value}; };
-
-//* is a type T a signed integral type provided by the compiler or standard
-template <typename T> struct is_signed_integral
-{ enum{ value = is_standard_signed_integral<T>::value | is_extension_signed_integral<T>::value}; };
-
-//* is a type T an integral type provided by the compiler or standard
-template <typename T> struct is_integral
-{ enum{ value = is_standard_integral<T>::value | is_extension_integral<T>::value}; };
-
-//* is a type T a floating-point type provided by the compiler or standard
-template <typename T> struct is_float
-{ enum{ value = is_standard_float<T>::value | is_extension_float<T>::value}; };
-
-//* is a type T an arithmetic type provided by the compiler or standard
-template <typename T> struct is_arithmetic
-{ enum{ value = is_standard_arithmetic<T>::value | is_extension_arithmetic<T>::value}; };
-
-//* is a type T a fundamental type provided by the compiler or standard
-template <typename T> struct is_fundamental
-{ enum{ value = is_standard_fundamental<T>::value | is_extension_fundamental<T>::value}; };
-
-//* is a type T an array - is_array<T>
-namespace detail{
-   struct pointer_helper
-   {
-      pointer_helper(const volatile void*);
-   };
-   yes_result is_pointer_helper(pointer_helper);
-   no_result is_pointer_helper(...);
-   template <class T>
-   yes_result is_pointer_helper3(T (*)(void));
-   template <class T, class A1>
-   yes_result is_pointer_helper3(T (*)(A1));
-   template <class T, class A1, class A2>
-   yes_result is_pointer_helper3(T (*)(A1, A2));
-   template <class T, class A1, class A2, class A3>
-   yes_result is_pointer_helper3(T (*)(A1, A2, A3));
-   no_result is_pointer_helper3(...);
-
-   yes_result is_array_helper(const volatile void*, const volatile void*);
-   template <class T>
-   no_result is_array_helper(T**, const volatile void*);
-   no_result is_array_helper(...);
-}
-template <typename T> struct is_array
-{ 
-private:
-   static T t;
-public:
-   enum{ value = (1 == sizeof(detail::is_pointer_helper(t))) 
-                 & (1 == sizeof(detail::is_array_helper(&t, t)))
-                 & !is_reference<T>::value
-                 & !(1 == sizeof(detail::is_pointer_helper3(t))) }; 
-};
-
-//* is a type T a pointer type (including function pointers) - is_pointer<T>
-template <typename T> struct is_pointer 
-{ 
-private:
-   static T t;
-public:
-   enum{ value = (!is_const<T>::value 
-                 & !is_volatile<T>::value 
-                 & !is_reference<T>::value
-                 & !is_array<T>::value)
-                 & ((1 == sizeof(detail::is_pointer_helper(t)))
-                     | (1 == sizeof(detail::is_pointer_helper3(t)))) }; 
-};
-
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-
-//* is a type T a reference type - is_reference<T>
-template <typename T> struct is_reference 
-{ 
-private:
-   typedef T const volatile cv_t;
-public:
-   enum // dwa 10/27/00 - VC6.4 seems to choke on short-circuit (&&,||)
-   {    // evaluations in constant expressions
-       value = !is_const<cv_t>::value | !is_volatile<cv_t>::value
-   }; 
-};
-template <> struct is_reference<void> 
-{ 
-   enum{ value = false }; 
-};
-
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-
-//*? is a type T a union type - is_union<T>
-template <typename T> struct is_union
-{ enum{ value = BOOST_IS_UNION(T) }; };
-
-//*? is a type T an enum - is_enum<T>
-template <typename T> struct is_enum
-{ enum{ value = BOOST_IS_ENUM(T) }; };
-
-//* is a type T a member function pointer - is_member_pointer<T>
-namespace detail{
-   template <class T, class U>
-   yes_result is_member_pointer_helper(T (U::*));
-   template <class T, class U>
-   yes_result is_member_pointer_helper(T (U::*)(void));
-   template <class T, class U, class A1>
-   yes_result is_member_pointer_helper(T (U::*)(A1));
-   template <class T, class U, class A1, class A2>
-   yes_result is_member_pointer_helper(T (U::*)(A1, A2));
-   no_result is_member_pointer_helper(...);
-}
-template <typename T> struct is_member_pointer
-{ 
-private:
-   static T t;
-public:
-   enum{ value = (1 == sizeof(detail::is_member_pointer_helper(t))) }; 
-};
-
-//* is type T an object type (allows cv-qual)
-template <typename T> struct is_object
-{ enum{ value = !is_reference<T>::value & !is_void<T>::value }; };
-
-//* is type T a standard scalar type (allows cv-qual)
-template <typename T> struct is_standard_scalar
-{ enum{ value = is_standard_arithmetic<T>::value
-      | is_enum<T>::value
-      | is_pointer<T>::value
-      | is_member_pointer<T>::value }; };
-
-//* is type T an extension scalar type (allows cv-qual)
-template <typename T> struct is_extension_scalar
-{ enum{ value = is_extension_arithmetic<T>::value
-      | is_enum<T>::value
-      | is_pointer<T>::value
-      | is_member_pointer<T>::value }; };
-
-//* is type T a builtin scalar type (allows cv-qual)
-template <typename T> struct is_scalar
-{ enum{ value = is_arithmetic<T>::value
-      | is_enum<T>::value
-      | is_pointer<T>::value
-      | is_member_pointer<T>::value }; };
-
-//*? is a type T a class type (class/struct) - is_class<T>
-template <typename T> struct is_class
-{ enum{ value = BOOST_IS_CLASS(T) }; };
-
-//*? is a type T a compound type
-template <typename T> struct is_compound
-{ enum{ value = is_array<T>::value | is_pointer<T>::value
-      | is_reference<T>::value | is_class<T>::value | is_union<T>::value
-      | is_enum<T>::value | is_member_pointer<T>::value }; };
-
-//*? is type T a POD type (allows cv-qual)
-template <typename T> struct is_POD
-{ enum{ value = is_scalar<T>::value  //JM 7Jan2000
-      | BOOST_IS_POD(T) }; };
-
-namespace detail{
-
-    // This workaround is necessary to handle when From is void
-    // which is normally taken care of by the partial specialization
-    // of the is_convertible class.
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
-  struct from_not_void_conversion {
-    template <class From, class To>
-    struct bind {
-      static no_result check(...);
-      static yes_result check(To);
-    public:
-      void foo(); // avoid warning about all members being private
-      static From from;
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable:4244 4245 4135 4136 4051 4134) // disable all conversion warnings
-# endif
-      enum { exists = sizeof( check(from) ) == sizeof(yes_result) };
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif
-    };
-  };
-  struct from_is_void_conversion {
-    template <class From, class To>
-    struct bind {
-      enum { exists = is_void<To>::value };
-    };
-  };
-
-  template <class From>
-  struct conversion_helper {
-    typedef from_not_void_conversion type;
-  };
-  template <>
-  struct conversion_helper<void> {
-    typedef from_is_void_conversion type;
-  };
-#endif
-} // namespace detail
-
-template <class From, class To>
-class is_convertible
-{
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
- typedef typename detail::conversion_helper<From>::type Selector;
- typedef Selector::template bind<From,To> Conversion;
-public:
- enum { value = Conversion::exists };
-#else
-   static detail::no_result check(...);
-   static detail::yes_result check(To);
- public:
-   void foo(); // avoid warning about all members being private
-   static From from;
-   enum { value = sizeof( check(from) ) == sizeof(detail::yes_result) };
-#endif
-};
-
-template <class T>
-class alignment_of
-{
-   struct padded
-   {
-      char c;
-      T t;
-      padded();
-   };
-public:
-   enum{ value = sizeof(padded) - sizeof(T) };
-};
-
-//*? is type T an empty composite type (allows cv-qual)
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-
-namespace detail{
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
-   int i[256];
-};
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T>
-struct empty_helper_base
-{
-   enum{ value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)) };
-};
-
-template <typename T>
-struct empty_helper_nonbase
-{
-   enum{ value = false };
-};
-
-template <bool base>
-struct empty_helper_chooser
-{
-   template <class T>
-   struct rebind
-   {
-      typedef empty_helper_nonbase<T> type;
-   };
-};
-
-template <>
-struct empty_helper_chooser<true>
-{
-   template <class T>
-   struct rebind
-   {
-      typedef empty_helper_base<T> type;
-   };
-};
-
-} // namespace detail
-
-template <typename T> 
-struct is_empty
-{ 
-private:
-   typedef detail::empty_helper_chooser<
-      !is_convertible<T,int>::value
-      & !is_convertible<T,double>::value
-      & !is_pointer<T>::value
-      & !is_member_pointer<T>::value
-      & !is_array<T>::value
-      & !is_convertible<T, const volatile void*>::value> chooser;
-   typedef typename chooser::template rebind<T> bound_type;
-   typedef typename bound_type::type eh_type;
-public:
-   enum{ value = eh_type::value | BOOST_IS_EMPTY(T) }; 
-};
-
-#else
-template <typename T> struct is_empty
-{ enum{ value = BOOST_IS_EMPTY(T) }; };
-#endif
-
-//*? T has trivial default constructor (allows cv-qual)
-template <typename T> struct has_trivial_constructor
-{
-  enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) };
-};
-
-//*? T has trivial copy constructor (allows cv-qual)
-template <typename T> struct has_trivial_copy
-{
-  enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_COPY(T) };
-};
-
-//*? T has trivial assignment operator (allows cv-qual)
-template <typename T>
-struct has_trivial_assign
-{
-  enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_ASSIGN(T) };
-};
-
-//*? T has trivial destructor (allows cv-qual)
-template <typename T>
-struct has_trivial_destructor
-{
-  enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_DESTRUCTOR(T) };
-};
-
-} // namespace boost
-
-/**************************************************************************/
-
-//
-// undefine helper macro's:
-//
-#undef BOOST_IS_CLASS
-#undef BOOST_IS_ENUM
-#undef BOOST_IS_UNION
-#undef BOOST_IS_POD
-#undef BOOST_IS_EMPTY
-#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
-#undef BOOST_HAS_TRIVIAL_COPY
-#undef BOOST_HAS_TRIVIAL_ASSIGN
-#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
-
-#endif // BOOST_OB_TYPE_TRAITS_HPP
-
-
-
-
-
--- a/include/boost/detail/type_traits.hpp
+++ b/include/boost/detail/type_traits.hpp
@ -1,675 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-//
-// misc traits classes that operate on or describe a type.
-// see libs/utility/type_traits.htm
-
-/* Release notes:
-   31 Jan 2001:
-      Fixed is_convertible warning for g++. Added specialization of
-      is_array to handle the const array case. Added parenthesis are
-      body of BOOST_IS_CLASS to prevent macro mistakes. (Jeremy Siek)
-   21 Jan 2001:
-      Fixed tests for long long to detect its presence on GCC (David Abrahams)
-   03 Oct 2000:
-      Added gcc specific fixes for memeber pointers (JM).
-   31st July 2000:
-      Added is_convertable, alignment_of, modified is_empty.
-   23rd July 2000:
-      Added Borland specific fixes for reference types (Steve Cleary).
-*/
-
-//
-// partial copyright for is_convertible:
-//
-// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu)
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy and use this software is granted, 
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted, 
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-
-#ifndef BOOST_DETAIL_TYPE_TRAITS_HPP
-#define BOOST_DETAIL_TYPE_TRAITS_HPP
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#error Internal header file: This header must be included by <boost/type_traits.hpp> only.
-#endif
-
-#include <cstddef>
-#include <climits>                         
-
-//
-// Helper macros for builitin compiler support.
-// If your compiler has builtin support for any of the following
-// traits concepts, then redefine the appropriate macros to pick
-// up on the compiler support:
-//
-// (these should return false if T is cv-qualified; the type traits that use these
-//  will strip cv-qualification if necessary before passing T)
-// BOOST_IS_CLASS(T) should evaluate to true if T is a class or struct type
-// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type
-// BOOST_IS_UNION(T) should evaluate to true if T is a union type
-// BOOST_IS_POD(T) should evaluate to true if T is a POD type
-// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union
-// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
-// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
-// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
-// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
-
-#define BOOST_IS_CLASS(T) (!is_union<T>::value && \
-    !is_scalar<T>::value && \
-    !is_array<T>::value && \
-    !is_reference<T>::value && \
-    !is_void<T>::value)
-#define BOOST_IS_ENUM(T) false
-#define BOOST_IS_UNION(T) false
-#define BOOST_IS_POD(T) false
-#define BOOST_IS_EMPTY(T) false
-#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
-#define BOOST_HAS_TRIVIAL_COPY(T) false
-#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
-#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
-
-
-/**************************************************************************/
-
-namespace boost{
-//
-// start with fundamental type operations:
-
-namespace details {
-//
-// implementation helper:
-//
-template <class T>
-struct cv_traits_imp{};
-
-template <class T>
-struct cv_traits_imp<T*>
-{
-   static const bool is_const = false;
-   static const bool is_volatile = false;
-   typedef T non_const_type;
-   typedef T non_volatile_type;
-   typedef T unqualified_type;
-   static const char* what() { return ""; }
-};
-
-template <class T>
-struct cv_traits_imp<const T*>
-{
-   static const bool is_const = true;
-   static const bool is_volatile = false;
-   typedef T non_const_type;
-   typedef const T non_volatile_type;
-   typedef T unqualified_type;
-   static const char* what() { return "const"; }
-};
-
-template <class T>
-struct cv_traits_imp<volatile T*>
-{
-   static const bool is_const = false;
-   static const bool is_volatile = true;
-   typedef volatile T non_const_type;
-   typedef T non_volatile_type;
-   typedef T unqualified_type;
-   static const char* what() { return "volatile"; }
-};
-
-template <class T>
-struct cv_traits_imp<const volatile T*>
-{
-   static const bool is_const = true;
-   static const bool is_volatile = true;
-   typedef volatile T non_const_type;
-   typedef const T non_volatile_type;
-   typedef T unqualified_type;
-   static const char* what() { return "const volatile"; }
-};
-
-} // namespace details
-
-// * convert a type T to a non-volatile type - remove_volatile<T>
-template <typename T>
-struct remove_volatile
-{
-   typedef typename details::cv_traits_imp<T*>::non_volatile_type type;
-};
-template <typename T> struct remove_volatile<T&>{ typedef T& type; };
-
-// * convert a type T to non-const type - remove_const<T>
-template <typename T>
-struct remove_const
-{
-   typedef typename details::cv_traits_imp<T*>::non_const_type type;
-};
-template <typename T> struct remove_const<T&>{ typedef T& type; };
-
-//  convert a type T to a non-cv-qualified type - remove_cv<T>
-template <typename T>
-struct remove_cv
-{
-   typedef typename details::cv_traits_imp<T*>::unqualified_type type;
-};
-template <typename T> struct remove_cv<T&>{ typedef T& type; };
-
-// * convert a type T to a non-reference if it is one - remove_reference<T>
-template <typename T> struct remove_reference{ typedef T type; };
-template <typename T> struct remove_reference<T&>{ typedef T type; };
-#if (defined(__BORLANDC__) && (__BORLANDC__ <= 0x550))
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct remove_reference<T&const>{ typedef T type; };
-template <typename T> struct remove_reference<T&volatile>{ typedef T type; };
-template <typename T> struct remove_reference<T&const volatile>{ typedef T type; };
-#endif
-// * convert a type T to a reference unless it is one - add_reference<T>
-template <typename T> struct add_reference{ typedef T& type; };
-template <typename T> struct add_reference<T&>{ typedef T& type; };
-
-// * convert an array type to underlying non-array type - remove_bounds<T>
-template <typename T> struct remove_bounds{ typedef T type; };
-template <typename T, std::size_t N> struct remove_bounds<T[N]>{ typedef T type; };
-
-/**************************************************************************/
-//
-// fundamental property classes:
-
-//* is a type T  declared const - is_const<T>
-template <typename T>
-struct is_const
-{
-   static const bool value = details::cv_traits_imp<T*>::is_const;
-};
-
-//* is a type T declared volatile - is_volatile<T>
-template <typename T>
-struct is_volatile
-{
-   static const bool value = details::cv_traits_imp<T*>::is_volatile;
-};
-
-//* is a type T the same as type U - is_same<T,U>
-template <typename T, typename U> struct is_same { static const bool value = false; };
-template <typename T> struct is_same<T, T> { static const bool value = true; };
-
-//* is a type T void - is_void<T>
-template <typename T> struct is_void{ static const bool value = false; };
-template <> struct is_void<void>{ static const bool value = true; };
-
-//* is a type T an unsigned integral type described in the standard (3.9.1p3)
-template <typename T> struct is_standard_unsigned_integral
-{ static const bool value = false; };
-template <> struct is_standard_unsigned_integral<unsigned char>
-{ static const bool value = true; };
-template <> struct is_standard_unsigned_integral<unsigned short>
-{ static const bool value = true; };
-template <> struct is_standard_unsigned_integral<unsigned int>
-{ static const bool value = true; };
-template <> struct is_standard_unsigned_integral<unsigned long>
-{ static const bool value = true; };
-
-//* is a type T a signed integral type described in the standard (3.9.1p2)
-template <typename T> struct is_standard_signed_integral
-{ static const bool value = false; };
-template <> struct is_standard_signed_integral<signed char>
-{ static const bool value = true; };
-template <> struct is_standard_signed_integral<signed short>
-{ static const bool value = true; };
-template <> struct is_standard_signed_integral<signed int>
-{ static const bool value = true; };
-template <> struct is_standard_signed_integral<signed long>
-{ static const bool value = true; };
-
-//* is a type T an integral type described in the standard (3.9.1p7)
-template <typename T> struct is_standard_integral
-{ static const bool value = is_standard_unsigned_integral<T>::value ||
-      is_standard_signed_integral<T>::value; };
-template <> struct is_standard_integral<char>
-{ static const bool value = true; };
-template <> struct is_standard_integral<wchar_t>
-{ static const bool value = true; };
-template <> struct is_standard_integral<bool>
-{ static const bool value = true; };
-
-//* is a type T a floating-point type described in the standard (3.9.1p8)
-template <typename T> struct is_standard_float
-{ static const bool value = false; };
-template <> struct is_standard_float<float>
-{ static const bool value = true; };
-template <> struct is_standard_float<double>
-{ static const bool value = true; };
-template <> struct is_standard_float<long double>
-{ static const bool value = true; };
-
-//* is a type T an arithmetic type described in the standard (3.9.1p8)
-template <typename T> struct is_standard_arithmetic
-{ static const bool value = is_standard_integral<T>::value || is_standard_float<T>::value; };
-
-//* is a type T a fundamental type described in the standard (3.9.1)
-template <typename T> struct is_standard_fundamental
-{ static const bool value = is_standard_arithmetic<T>::value || is_void<T>::value; };
-
-//* is a type T an unsigned integral type provided by a compiler extension
-// specialise for compiler defined extentions:
-template <typename T> struct is_extension_unsigned_integral
-{ static const bool value = false; };
-
-//* is a type T a signed integral type provided by a compiler extension
-// specialise for compiler defined extentions:
-template <typename T> struct is_extension_signed_integral
-{ static const bool value = false; };
-
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
-template <> struct is_extension_unsigned_integral<unsigned long long>
-{ static const bool value = true; };
-template <> struct is_extension_signed_integral<long long>
-{ static const bool value = true; };
-#endif
-#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
-template <> struct is_extension_unsigned_integral<unsigned __int64>
-{ static const bool value = true; };
-template <> struct is_extension_signed_integral<__int64>
-{ static const bool value = true; };
-#endif
-
-//* is a type T an integral type provided by a compiler extension
-template <typename T> struct is_extension_integral
-{ static const bool value = is_extension_signed_integral<T>::value ||
-      is_extension_unsigned_integral<T>::value; };
-
-//* is a type T a floating-point type provided by a compiler extension
-template <typename T> struct is_extension_float
-{ static const bool value = false; };
-
-//* is a type T an arithmetic type provided by a compiler extension
-template <typename T> struct is_extension_arithmetic
-{ static const bool value = is_extension_integral<T>::value || is_extension_float<T>::value; };
-
-//* is a type T a fundamental type provided by a compiler extension
-template <typename T> struct is_extension_fundamental
-{ static const bool value = is_extension_arithmetic<T>::value || is_void<T>::value; };
-
-//* is a type T an unsigned integral type provided by the compiler or standard
-template <typename T> struct is_unsigned_integral
-{ static const bool value = is_standard_unsigned_integral<T>::value || is_extension_unsigned_integral<T>::value; };
-
-//* is a type T a signed integral type provided by the compiler or standard
-template <typename T> struct is_signed_integral
-{ static const bool value = is_standard_signed_integral<T>::value || is_extension_signed_integral<T>::value; };
-
-//* is a type T an integral type provided by the compiler or standard
-template <typename T> struct is_integral
-{ static const bool value = is_standard_integral<T>::value || is_extension_integral<T>::value; };
-
-//* is a type T a floating-point type provided by the compiler or standard
-template <typename T> struct is_float
-{ static const bool value = is_standard_float<T>::value || is_extension_float<T>::value; };
-
-//* is a type T an arithmetic type provided by the compiler or standard
-template <typename T> struct is_arithmetic
-{ static const bool value = is_standard_arithmetic<T>::value || is_extension_arithmetic<T>::value; };
-
-//* is a type T a fundamental type provided by the compiler or standard
-template <typename T> struct is_fundamental
-{ static const bool value = is_standard_fundamental<T>::value || is_extension_fundamental<T>::value; };
-
-//* is a type T an array - is_array<T>
-template <typename T> struct is_array
-{ static const bool value = false; };
-template <typename T, std::size_t N> struct is_array<T[N]>
-{ static const bool value = true; };
-template <typename T, std::size_t N> struct is_array<const T[N]>
-{ static const bool value = true; };
-
-//* is a type T a pointer type (including function pointers) - is_pointer<T>
-template <typename T> struct is_pointer { static const bool value = false; };
-template <typename T> struct is_pointer<T*> { static const bool value = true; };
-#ifdef __GNUC__
-// gcc workarounds: these partial specialisations should not be needed:
-template <typename T, typename U> struct is_pointer<U T::*>
-{ static const bool value = false; };
-template <typename T, typename U> struct is_pointer<U (T::*)(void)>
-{ static const bool value = false; };
-template <typename T, typename U, typename A1> struct is_pointer<U (T::*)(A1)>
-{ static const bool value = false; };
-template <typename T, typename U, typename A1, typename A2> struct is_pointer<U (T::*)(A1, A2)>
-{ static const bool value = false; };
-#endif
-
-//* is a type T a reference type - is_reference<T>
-template <typename T> struct is_reference { static const bool value = false; };
-template <typename T> struct is_reference<T&> { static const bool value = true; };
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct is_reference<T&const> { static const bool value = true; };
-template <typename T> struct is_reference<T&volatile> { static const bool value = true; };
-template <typename T> struct is_reference<T&const volatile> { static const bool value = true; };
-#endif
-
-//*? is a type T a union type - is_union<T>
-template <typename T> struct is_union
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = BOOST_IS_UNION(cvt);
-};
-
-//*? is a type T an enum - is_enum<T>
-template <typename T> struct is_enum
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = BOOST_IS_ENUM(cvt);
-};
-
-//* is a type T a member function pointer - is_member_pointer<T>
-template <typename T> struct is_member_pointer
-{ static const bool value = false; };
-template <typename T, typename U> struct is_member_pointer<U T::*>
-{ static const bool value = true; };
-#ifdef __GNUC__
-// gcc workaround (JM 02 Oct 2000)
-template <typename T, typename U> struct is_member_pointer<U (T::*)(void)>
-{ static const bool value = true; };
-template <typename T, typename U, typename A1> struct is_member_pointer<U (T::*)(A1)>
-{ static const bool value = true; };
-template <typename T, typename U, typename A1, typename A2> struct is_member_pointer<U (T::*)(A1, A2)>
-{ static const bool value = true; };
-#endif
-
-//* is type T an object type (allows cv-qual)
-template <typename T> struct is_object
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = !::boost::is_reference<cvt>::value
-      && !::boost::is_void<cvt>::value;
-};
-
-//* is type T a standard scalar type (allows cv-qual)
-template <typename T> struct is_standard_scalar
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = is_standard_arithmetic<cvt>::value
-      || is_enum<cvt>::value
-      || is_pointer<cvt>::value
-      || is_member_pointer<cvt>::value;
-};
-
-//* is type T an extension scalar type (allows cv-qual)
-template <typename T> struct is_extension_scalar
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = is_extension_arithmetic<cvt>::value
-      || is_enum<cvt>::value
-      || is_pointer<cvt>::value
-      || is_member_pointer<cvt>::value;
-};
-
-//* is type T a builtin scalar type (allows cv-qual)
-template <typename T> struct is_scalar
-{ 
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = is_arithmetic<cvt>::value
-      || is_enum<cvt>::value
-      || is_pointer<cvt>::value
-      || is_member_pointer<cvt>::value; 
-};
-
-//*? is a type T a class type (class/struct) - is_class<T>
-template <typename T> struct is_class
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = BOOST_IS_CLASS(cvt); 
-};
-
-//*? is a type T a compound type
-template <typename T> struct is_compound
-{ static const bool value = is_array<T>::value || is_pointer<T>::value
-      || is_reference<T>::value || is_class<T>::value || is_union<T>::value
-      || is_enum<T>::value || is_member_pointer<T>::value; };
-
-//*? is type T a POD type (allows cv-qual)
-template <typename T> struct is_POD
-{ 
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   static const bool value = is_scalar<cvt>::value || BOOST_IS_POD(cvt); 
-};
-template <typename T, std::size_t sz> struct is_POD<T[sz]>
-{ static const bool value = is_POD<T>::value; };
-
-//
-// Thanks to Andrei Alexandrescu for the original version of this
-// conversion class!
-//
-// is one type convertable to another?
-template <class From, class To>
-struct is_convertible
-{
-private:
- typedef char (&no)[1];
- typedef char (&yes)[2];
- // The workarounds for Borland and GNU C++ break the EDG C++ frontend,
- // so we only use them for those compilers.
-#if defined(__GNUC__)
- struct accept_any {
-   template <class T> accept_any(const T&);
- };
- template <class T>
- struct checker
- {
-   // Need two arguments in the check functions to bias resolution
-   // towards the "yes" in the case when the From type has an implicit
-   // conversion operator defined for the To type, which would
-   // otherwise be an ambiguous situation.
-   static no check(accept_any, accept_any);
-   static yes check(T, From);
- };
- static From from;
-public:
- static const bool value = 
-   sizeof( checker<To>::check(from, from) ) == sizeof(yes);
-#elif defined(__BORLANDC__)
- template <class T>
- struct checker
- {
-   static no check(...);
-   static yes check(T);
- };
- static From from;
-public:
- static const bool value = sizeof( checker<To>::check(from) ) == sizeof(yes);
-#  else // not __BORLANDC__ or __GNUC__
- static no check(...);
- static yes check(To);
- static From from;
-public:
- static const bool value = sizeof( check(from) ) == sizeof(yes);
-#  endif
- void foo(); // avoid warning about all members being private
-};
-
-template <class From>
-struct is_convertible<From, void>
-{
-   static const bool value = false;
-};
-template <class To>
-struct is_convertible<void, To>
-{
-   static const bool value = false;
-};
-template <>
-struct is_convertible<void, void>
-{
-   static const bool value = true;
-};
-//
-// get the alignment of some arbitrary type:
-namespace detail{
-// hack for MWCW:
-template <class T>
-class alignment_of_hack
-{
-   char c;
-   T t;
-   alignment_of_hack();
-};
-}
-template <class T>
-class alignment_of
-{
-public:
-   static const unsigned value = sizeof(detail::alignment_of_hack<T>) - sizeof(T);
-};
-//
-// references have to be treated specially, assume
-// that a reference is just a special pointer:
-template <class T>
-class alignment_of<T&>
-{
-public:
-   static const unsigned value = alignment_of<T*>::value;
-};
-
-//
-// JM 7Jan2000
-// 
-namespace detail{
-template <typename T, bool b, bool b2>
-struct empty_helper{ static const bool value = false; };
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
-#ifdef __MWERKS__
-   empty_helper_t1();  // hh compiler bug workaround
-#endif
-   int i[256];
-};
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T>
-struct empty_helper<T, true, false>
-{
-   static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));
-};
-}
-
-//*? is type T an empty composite type (allows cv-qual)
-template <typename T> struct is_empty
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-#ifdef __GNUC__
-   // is_convertible gives a warning for g++
-   static const bool value = ::boost::detail::empty_helper<T, is_class<T>::value , false>::value
-                     || BOOST_IS_EMPTY(cvt);
-
-#else
-   static const bool value = ::boost::detail::empty_helper<T, is_class<T>::value , is_convertible<T,int>::value>::value
-                     || BOOST_IS_EMPTY(cvt);
-#endif
-};
-
-//*? T has trivial default constructor (allows cv-qual)
-template <typename T> struct has_trivial_constructor
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-  static const bool value = is_POD<T>::value
-      || BOOST_HAS_TRIVIAL_CONSTRUCTOR(cvt);
-};
-
-//*? T has trivial copy constructor (allows cv-qual)
-template <typename T> struct has_trivial_copy
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-  static const bool value = is_POD<T>::value
-      || BOOST_HAS_TRIVIAL_COPY(cvt);
-};
-
-//*? T has trivial assignment operator (allows cv-qual)
-template <typename T>
-struct has_trivial_assign
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-  static const bool value = is_POD<T>::value
-      || BOOST_HAS_TRIVIAL_ASSIGN(cvt);
-};
-
-//*? T has trivial destructor (allows cv-qual)
-template <typename T>
-struct has_trivial_destructor
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-  static const bool value = is_POD<T>::value
-      || BOOST_HAS_TRIVIAL_DESTRUCTOR(cvt);
-};
-
-} // namespace boost
-
-/**************************************************************************/
-
-//
-// undefine helper macro's:
-//
-#undef BOOST_IS_CLASS
-#undef BOOST_IS_ENUM
-#undef BOOST_IS_UNION
-#undef BOOST_IS_POD
-#undef BOOST_IS_EMPTY
-#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
-#undef BOOST_HAS_TRIVIAL_COPY
-#undef BOOST_HAS_TRIVIAL_ASSIGN
-#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
-
-#endif // BOOST_DETAIL_TYPE_TRAITS_HPP
-
-
-
-
-
-
-
-
--- a/include/boost/type_traits.hpp
+++ b/include/boost/type_traits.hpp
@ -1,43 +1,80 @@
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  (C) Copyright John Maddock 2000. 
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

-//  See http://www.boost.org for most recent version including documentation.
-//  See boost/detail/type_traits.hpp and boost/detail/ob_type_traits.hpp
-//  for full copyright notices.
+//  See boost/type_traits/*.hpp for full copyright notices.

 #ifndef BOOST_TYPE_TRAITS_HPP
 #define BOOST_TYPE_TRAITS_HPP

-#include <boost/type_traits/fwd.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/type_traits/arithmetic_traits.hpp>
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/type_traits/composite_traits.hpp>
-#include <boost/type_traits/alignment_traits.hpp>
-#include <boost/type_traits/object_traits.hpp>
-#include <boost/type_traits/transform_traits.hpp>
-#include <boost/type_traits/same_traits.hpp>
-#include <boost/type_traits/function_traits.hpp>
+#include "boost/type_traits/add_const.hpp"
+#include "boost/type_traits/add_cv.hpp"
+#include "boost/type_traits/add_pointer.hpp"
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/add_volatile.hpp"
+#include "boost/type_traits/alignment_of.hpp"
+#include "boost/type_traits/has_nothrow_assign.hpp"
+#include "boost/type_traits/has_nothrow_constructor.hpp"
+#include "boost/type_traits/has_nothrow_copy.hpp"
+#include "boost/type_traits/has_nothrow_destructor.hpp"
+#include "boost/type_traits/has_trivial_assign.hpp"
+#include "boost/type_traits/has_trivial_constructor.hpp"
+#include "boost/type_traits/has_trivial_copy.hpp"
+#include "boost/type_traits/has_trivial_destructor.hpp"
+#include "boost/type_traits/has_virtual_destructor.hpp"
+#include "boost/type_traits/is_signed.hpp"
+#include "boost/type_traits/is_unsigned.hpp"
+#include "boost/type_traits/is_abstract.hpp"
+#include "boost/type_traits/is_arithmetic.hpp"
+#include "boost/type_traits/is_array.hpp"
+#include "boost/type_traits/is_base_and_derived.hpp"
+#include "boost/type_traits/is_base_of.hpp"
+#include "boost/type_traits/is_class.hpp"
+#include "boost/type_traits/is_compound.hpp"
+#include "boost/type_traits/is_const.hpp"
+#include "boost/type_traits/is_convertible.hpp"
+#include "boost/type_traits/is_empty.hpp"
+#include "boost/type_traits/is_enum.hpp"
+#include "boost/type_traits/is_float.hpp"
+#include "boost/type_traits/is_floating_point.hpp"
+#include "boost/type_traits/is_function.hpp"
+#include "boost/type_traits/is_fundamental.hpp"
+#include "boost/type_traits/is_integral.hpp"
+#include "boost/type_traits/is_member_function_pointer.hpp"
+#include "boost/type_traits/is_member_object_pointer.hpp"
+#include "boost/type_traits/is_member_pointer.hpp"
+#include "boost/type_traits/is_object.hpp"
+#include "boost/type_traits/is_pod.hpp"
+#include "boost/type_traits/is_polymorphic.hpp"
+#include "boost/type_traits/is_pointer.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/type_traits/is_same.hpp"
+#include "boost/type_traits/is_scalar.hpp"
+#include "boost/type_traits/is_stateless.hpp"
+#include "boost/type_traits/is_union.hpp"
+#include "boost/type_traits/is_void.hpp"
+#include "boost/type_traits/is_volatile.hpp"
+#include "boost/type_traits/rank.hpp"
+#include "boost/type_traits/extent.hpp"
+#include "boost/type_traits/remove_bounds.hpp"
+#include "boost/type_traits/remove_extent.hpp"
+#include "boost/type_traits/remove_all_extents.hpp"
+#include "boost/type_traits/remove_const.hpp"
+#include "boost/type_traits/remove_cv.hpp"
+#include "boost/type_traits/remove_pointer.hpp"
+#include "boost/type_traits/remove_reference.hpp"
+#include "boost/type_traits/remove_volatile.hpp"
+#include "boost/type_traits/type_with_alignment.hpp"
+#include "boost/type_traits/function_traits.hpp"
+#include "boost/type_traits/aligned_storage.hpp"

-/**************************************************************************/
-
-//
-// undefine helper macro's:
-//
-#undef BOOST_IS_CLASS
-#undef BOOST_IS_ENUM
-#undef BOOST_IS_UNION
-#undef BOOST_IS_POD
-#undef BOOST_IS_EMPTY
-#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
-#undef BOOST_HAS_TRIVIAL_COPY
-#undef BOOST_HAS_TRIVIAL_ASSIGN
-#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
+#include "boost/type_traits/ice.hpp"

 #endif // BOOST_TYPE_TRAITS_HPP



+
--- a/include/boost/type_traits/add_const.hpp
+++ b/include/boost/type_traits/add_const.hpp
@ -0,0 +1,47 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED
+#define BOOST_TT_ADD_CONST_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+// * convert a type T to const type - add_const<T>
+// this is not required since the result is always
+// the same as "T const", but it does suppress warnings
+// from some compilers:
+
+#if defined(BOOST_MSVC)
+// This bogus warning will appear when add_const is applied to a
+// const volatile reference because we can't detect const volatile
+// references with MSVC6.
+#   pragma warning(push)
+#   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
+#endif 
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const)
+
+#if defined(BOOST_MSVC)
+#   pragma warning(pop)
+#endif 
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED
--- a/include/boost/type_traits/add_cv.hpp
+++ b/include/boost/type_traits/add_cv.hpp
@ -0,0 +1,48 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_ADD_CV_HPP_INCLUDED
+#define BOOST_TT_ADD_CV_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+// * convert a type T to a const volatile type - add_cv<T>
+// this is not required since the result is always
+// the same as "T const volatile", but it does suppress warnings
+// from some compilers:
+
+#if defined(BOOST_MSVC)
+// This bogus warning will appear when add_volatile is applied to a
+// const volatile reference because we can't detect const volatile
+// references with MSVC6.
+#   pragma warning(push)
+#   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
+#endif 
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_cv,T,T const volatile)
+
+#if defined(BOOST_MSVC)
+#   pragma warning(pop)
+#endif 
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_CV_HPP_INCLUDED
--- a/include/boost/type_traits/add_pointer.hpp
+++ b/include/boost/type_traits/add_pointer.hpp
@ -0,0 +1,72 @@
+
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ADD_POINTER_HPP_INCLUDED
+#define BOOST_TT_ADD_POINTER_HPP_INCLUDED
+
+#include <boost/type_traits/remove_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+//
+// For some reason this implementation stops Borlands compiler
+// from dropping cv-qualifiers, it still fails with references
+// to arrays for some reason though (shrug...) (JM 20021104)
+//
+template <typename T>
+struct add_pointer_impl
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&const>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&volatile>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&const volatile>
+{
+    typedef T* type;
+};
+
+#else
+
+template <typename T>
+struct add_pointer_impl
+{
+    typedef typename remove_reference<T>::type no_ref_type;
+    typedef no_ref_type* type;
+};
+
+#endif
+
+} // namespace detail
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename boost::detail::add_pointer_impl<T>::type)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED
--- a/include/boost/type_traits/add_reference.hpp
+++ b/include/boost/type_traits/add_reference.hpp
@ -0,0 +1,89 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
+#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
+
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+template <bool x>
+struct reference_adder
+{
+    template <typename T> struct result_
+    {
+        typedef T& type;
+    };
+};
+
+template <>
+struct reference_adder<true>
+{
+    template <typename T> struct result_
+    {
+        typedef T type;
+    };
+};
+
+template <typename T>
+struct add_reference_impl
+{
+    typedef typename reference_adder<
+          ::boost::is_reference<T>::value
+        >::template result_<T> result;
+
+    typedef typename result::type type;
+};
+
+#else
+
+template <typename T>
+struct add_reference_impl
+{
+    typedef T& type;
+};
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
+#endif
+
+#endif
+
+// these full specialisations are always required:
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const)
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile)
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile)
+#endif
+
+} // namespace detail
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename boost::detail::add_reference_impl<T>::type)
+
+// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional
+// level of indirection, here
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
--- a/include/boost/type_traits/add_volatile.hpp
+++ b/include/boost/type_traits/add_volatile.hpp
@ -0,0 +1,47 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
+#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+// * convert a type T to volatile type - add_volatile<T>
+// this is not required since the result is always
+// the same as "T volatile", but it does suppress warnings
+// from some compilers:
+
+#if defined(BOOST_MSVC)
+// This bogus warning will appear when add_volatile is applied to a
+// const volatile reference because we can't detect const volatile
+// references with MSVC6.
+#   pragma warning(push)
+#   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
+#endif 
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile)
+
+#if defined(BOOST_MSVC)
+#   pragma warning(pop)
+#endif 
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
--- a/include/boost/type_traits/aligned_storage.hpp
+++ b/include/boost/type_traits/aligned_storage.hpp
@ -0,0 +1,13 @@
+
+//  Copyright (C) John Maddock 2005.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
+#  define BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
+#  include <boost/aligned_storage.hpp>
+#endif // BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
+
--- a/include/boost/type_traits/alignment_of.hpp
+++ b/include/boost/type_traits/alignment_of.hpp
@ -0,0 +1,100 @@
+
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+// should be the last #include
+#include <boost/type_traits/detail/size_t_trait_def.hpp>
+
+#ifdef BOOST_MSVC
+#   pragma warning(push)
+#   pragma warning(disable: 4121) // alignment is sensitive to packing
+#endif
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#pragma option push -Vx- -Ve-
+#endif
+
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+// get the alignment of some arbitrary type:
+namespace detail {
+
+template <typename T>
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value =
+        (::boost::detail::alignment_logic<
+            sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+            sizeof(T)
+        >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl<T>::value)
+
+// references have to be treated specially, assume
+// that a reference is just a special pointer:
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <typename T>
+struct alignment_of<T&>
+    : alignment_of<T*>
+{
+};
+#endif
+#ifdef __BORLANDC__
+// long double gives an incorrect value of 10 (!)
+// unless we do this...
+struct long_double_wrapper{ long double ld; };
+template<> struct alignment_of<long double>
+   : public alignment_of<long_double_wrapper>{};
+#endif
+
+// void has to be treated specially:
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0)
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0)
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0)
+#endif
+
+} // namespace boost
+
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#pragma option pop
+#endif
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
+
+#include <boost/type_traits/detail/size_t_trait_undef.hpp>
+
+#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+
--- a/include/boost/type_traits/alignment_traits.hpp
+++ b/include/boost/type_traits/alignment_traits.hpp
@ -1,84 +1,15 @@

 //  (C) Copyright John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
-// defines alignment_of:
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

-#ifndef ALIGNMENT_TYPE_TRAITS_HPP
-#define ALIGNMENT_TYPE_TRAITS_HPP
+#ifndef BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED
+#define BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED

-#include <cstdlib>
-#include <cstddef>
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-
-namespace boost{
-//
-// get the alignment of some arbitrary type:
-namespace detail{
-
-template <class T>
-struct alignment_of_hack
-{
-   char c;
-   T t;
-   alignment_of_hack();
-};
-
-template <unsigned A, unsigned S>
-struct alignment_logic
-{
-   BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
-};
-
-} // namespace detail
-
-template <class T>
-struct alignment_of
-{
-   BOOST_STATIC_CONSTANT(std::size_t, value =
-      (::boost::detail::alignment_logic<
-         sizeof(detail::alignment_of_hack<T>) - sizeof(T),
-         sizeof(T)
-      >::value));
-};
-
-//
-// references have to be treated specially, assume
-// that a reference is just a special pointer:
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct alignment_of<T&>
-{
-public:
-   BOOST_STATIC_CONSTANT(std::size_t, value = ::boost::alignment_of<T*>::value);
-};
-#endif
-//
-// void has to be treated specially:
-template <>
-struct alignment_of<void>
-{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); };
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct alignment_of<const void>
-{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); };
-template <>
-struct alignment_of<volatile void>
-{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); };
-template <>
-struct alignment_of<const volatile void>
-{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); };
-#endif
-
-} // namespace boost
-
-#endif // ALIGNMENT_TYPE_TRAITS_HPP
-
- 
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>

+#endif // BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/arithmetic_traits.hpp
+++ b/include/boost/type_traits/arithmetic_traits.hpp
@ -1,266 +1,20 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 //
 //  defines traits classes for arithmetic types:
 //  is_void, is_integral, is_float, is_arithmetic, is_fundamental.
-//
-
-//  Revision History:
-// Feb 19 2001 Added #include <climits> (David Abrahams)
-
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-#define BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-
-#include <limits.h> // for ULLONG_MAX/ULONG_LONG_MAX
-
-namespace boost{
-
-//* is a type T void - is_void<T>
-template <typename T> struct is_void{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <> struct is_void<void>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3)
-// as an extention we include long long, as this is likely to be added to the
-// standard at a later date
-template <typename T> struct is_integral
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <> struct is_integral<unsigned char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<unsigned short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<unsigned int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<unsigned long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<signed char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<signed short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<signed int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<signed long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template <> struct is_integral<wchar_t>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-template <> struct is_integral<bool>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-# if defined(BOOST_HAS_LONG_LONG)
-template <> struct is_integral<unsigned long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#elif defined(__BORLANDC__) || defined(_MSC_VER)
-template <> struct is_integral<unsigned __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<__int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-
-//* is a type T a floating-point type described in the standard (3.9.1p8)
-template <typename T> struct is_float
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <> struct is_float<float>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<long double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-//
-// declare cv-qualified specialisations of these templates only
-// if BOOST_NO_CV_SPECIALIZATIONS is not defined:
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_void<const void>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_void<volatile void>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_void<const volatile void>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-#ifndef BOOST_NO_CV_SPECIALIZATIONS
-// const-variations:
-template <> struct is_integral<const unsigned char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const unsigned short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const unsigned int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const unsigned long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const signed char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const signed short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const signed int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const signed long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template <> struct is_integral<const wchar_t>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-template <> struct is_integral<const bool>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-# if defined(BOOST_HAS_LONG_LONG)
-template <> struct is_integral<const unsigned long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#elif defined(__BORLANDC__) || defined(_MSC_VER)
-template <> struct is_integral<const unsigned __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif //__int64
-
-template <> struct is_float<const float>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<const double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<const long double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-// volatile-variations:
-template <> struct is_integral<volatile  unsigned char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  unsigned short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  unsigned int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  unsigned long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  signed char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  signed short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  signed int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  signed long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template <> struct is_integral<volatile  wchar_t>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-template <> struct is_integral<volatile  bool>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-# if defined(BOOST_HAS_LONG_LONG)
-template <> struct is_integral<volatile  unsigned long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#elif defined(__BORLANDC__) || defined(_MSC_VER)
-template <> struct is_integral<volatile  unsigned __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<volatile  __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif //__int64
-
-template <> struct is_float<volatile  float>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<volatile  double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<volatile  long double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-// const-volatile-variations:
-template <> struct is_integral<const volatile unsigned char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile unsigned short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile unsigned int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile unsigned long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile signed char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile signed short>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile signed int>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile signed long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile char>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template <> struct is_integral<const volatile wchar_t>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-template <> struct is_integral<const volatile bool>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-# if defined(BOOST_HAS_LONG_LONG)
-template <> struct is_integral<const volatile unsigned long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile long long>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#elif defined(__BORLANDC__) || defined(_MSC_VER)
-template <> struct is_integral<const volatile unsigned __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_integral<const volatile __int64>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif //__int64
-
-template <> struct is_float<const volatile float>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<const volatile double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <> struct is_float<const volatile long double>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-
-#endif // BOOST_NO_CV_SPECIALIZATIONS
-
-//* is a type T an arithmetic type described in the standard (3.9.1p8)
-template <typename T> 
-struct is_arithmetic
-{ 
-	BOOST_STATIC_CONSTANT(bool, value = 
-		(::boost::type_traits::ice_or< 
-			::boost::is_integral<T>::value,
-			::boost::is_float<T>::value
-		>::value)); 
-};
-
-//* is a type T a fundamental type described in the standard (3.9.1)
-template <typename T> 
-struct is_fundamental
-{ 
-	BOOST_STATIC_CONSTANT(bool, value = 
-		(::boost::type_traits::ice_or< 
-			::boost::is_arithmetic<T>::value, 
-			::boost::is_void<T>::value
-		>::value)); 
-};
-
-} // namespace boost
-
-#endif
-
-
-
-

+#ifndef BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
+#define BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED

+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_float.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_void.hpp>

+#endif // BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/array_traits.hpp
+++ b/include/boost/type_traits/array_traits.hpp
@ -0,0 +1,15 @@
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED
+#define BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED
+
+#include <boost/type_traits/is_array.hpp>
+
+#endif // BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/broken_compiler_spec.hpp
+++ b/include/boost/type_traits/broken_compiler_spec.hpp
@ -0,0 +1,117 @@
+
+//  Copyright 2001-2003 Aleksey Gurtovoy.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
+#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/config.hpp>
+
+// these are needed regardless of BOOST_TT_NO_BROKEN_COMPILER_SPEC 
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+namespace boost { namespace detail {
+template< typename T > struct remove_const_impl     { typedef T type; };
+template< typename T > struct remove_volatile_impl  { typedef T type; };
+template< typename T > struct remove_pointer_impl   { typedef T type; };
+template< typename T > struct remove_reference_impl { typedef T type; };
+typedef int invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces;
+}}
+#endif
+
+// agurt, 27/jun/03: disable the workaround if user defined 
+// BOOST_TT_NO_BROKEN_COMPILER_SPEC
+#if    !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+    || defined(BOOST_TT_NO_BROKEN_COMPILER_SPEC)
+
+#   define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/
+
+#else
+
+// same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it
+// never gets #undef-ined
+#   define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \
+template<> struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#   define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T)                         \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T)                    \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile)  \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T)              \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const)  \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T)                               \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T)                       \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const,T)                  \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*volatile,T)               \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const volatile,T)         \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T)                     \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T)                               \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T)                                      \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const)                                \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile)                             \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile)                       \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T)                                   \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T)                                      \
+    BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T)                                \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*)                                         \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*)                                \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*)                          \
+    /**/
+
+#   define BOOST_TT_BROKEN_COMPILER_SPEC(T)                                         \
+    namespace boost { namespace detail {                                            \
+    typedef invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces             \
+      please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces;           \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T)                                          \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T)                                          \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*)                                         \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*)                                \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*)                          \
+    }}                                                                              \
+    /**/
+
+#   include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+BOOST_TT_BROKEN_COMPILER_SPEC(bool)
+BOOST_TT_BROKEN_COMPILER_SPEC(char)
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t)
+#endif
+BOOST_TT_BROKEN_COMPILER_SPEC(signed char)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed short)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed int)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed long)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long)
+BOOST_TT_BROKEN_COMPILER_SPEC(float)
+BOOST_TT_BROKEN_COMPILER_SPEC(double)
+//BOOST_TT_BROKEN_COMPILER_SPEC(long double)
+
+// for backward compatibility
+#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \
+    BOOST_TT_BROKEN_COMPILER_SPEC(T) \
+/**/
+
+#endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
--- a/include/boost/type_traits/composite_traits.hpp
+++ b/include/boost/type_traits/composite_traits.hpp
@ -1,725 +1,28 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 //
 //  defines traits classes for composite types:
 //  is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union.
 //
-//    Fixed is_pointer, is_reference, is_const, is_volatile, is_same, 
-//    is_member_pointer based on the Simulated Partial Specialization work 
-//    of Mat Marcus and Jesse Jones. See 	http://opensource.adobe.com or 
-//    http://groups.yahoo.com/group/boost/message/5441 
-//    Some workarounds in here use ideas suggested from "Generic<Programming>: 
-//    Mappings between Types and Values" 
-//    by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
-//    Fixes for is_array are based on a newgroup posting by Jonathan Lundquist.

-//
-// Revision History:
-// 21st March 2001:
-//   Fixed is_enum so that it works with incomplete types.
+#ifndef BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED
+#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED

-#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
-#define BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_member_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_union.hpp>
+
+#endif // BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED

-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP
-#include <boost/type_traits/conversion_traits.hpp>
-#endif
-#ifndef BOOST_CV_TYPE_TRAITS_HPP
-#include <boost/type_traits/cv_traits.hpp>
-#endif
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-#ifndef BOOST_TRANSFORM_TRAITS_HPP
-#include <boost/type_traits/transform_traits.hpp>
-#endif
-
-namespace boost{
-
-/**********************************************
- *
- * is_array
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_array
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T, std::size_t N> struct is_array<T[N]>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T, std::size_t N> struct is_array<const T[N]>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T, std::size_t N> struct is_array<volatile T[N]>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T, std::size_t N> struct is_array<const volatile T[N]>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-   struct pointer_helper
-   {
-      pointer_helper(const volatile void*);
-   };
-   yes_type is_pointer_helper(pointer_helper);
-   no_type is_pointer_helper(...);
-
-::boost::type_traits::no_type is_function_tester(...);
-template <class R>
-::boost::type_traits::yes_type is_function_tester(R (*)(void));
-template <class R, class A0>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0));
-template <class R, class A0, class A1>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1));
-template <class R, class A0, class A1, class A2>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2));
-template <class R, class A0, class A1, class A2, class A3>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3));
-template <class R, class A0, class A1, class A2, class A3, class A4>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28));
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29>
-::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29));
-
-
-   yes_type is_array_helper(const volatile void*, const volatile void*);
-   template <class T>
-   no_type is_array_helper(T*const volatile*, const volatile void*);
-   no_type is_array_helper(...);
-} // namespace detail
-template <typename T> 
-struct is_array
-{ 
-private:
-   static T t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = 
-      (::boost::type_traits::ice_and<
-         (1 == sizeof(detail::is_array_helper(&t, t))),
-         ::boost::type_traits::ice_not<
-            ::boost::is_reference<T>::value>::value,
-         ::boost::type_traits::ice_not<
-            (1 == sizeof(detail::is_function_tester(t)))>::value
-      >::value));
-};
-template <> 
-struct is_array<void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> 
-struct is_array<const void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <> 
-struct is_array<volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <> 
-struct is_array<const volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#endif
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-/**********************************************
- *
- * is_pointer
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-template <typename T> struct is_pointer_helper
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_pointer_helper<T*>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T> struct is_pointer_helper<T*const>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T> struct is_pointer_helper<T*volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T> struct is_pointer_helper<T*const volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-} // namespace detail
-template <typename T> struct is_pointer
-{ BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value)); };
-#else
-template <typename T>
-struct is_pointer 
-{ 
-private:
-   static T t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value =
-                (::boost::type_traits::ice_and<
-                  ::boost::type_traits::ice_not<
-                     ::boost::is_reference<T>::value
-                  >::value,
-                  ::boost::type_traits::ice_not<
-                     ::boost::is_array<T>::value
-                  >::value,
-                  (::boost::type_traits::ice_or<
-                       (1 == sizeof(detail::is_pointer_helper(t))),
-                       (1 == sizeof(detail::is_function_tester(t)))
-                  >::value)
-                >::value ) );
-};
-template <>
-struct is_pointer <void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_pointer <const void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <>
-struct is_pointer <volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <>
-struct is_pointer <const volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#endif
-#endif
-
-/**********************************************
- *
- * is_reference
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_reference 
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_reference<T&> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#if defined(__BORLANDC__)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct is_reference<T&const> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T> struct is_reference<T&volatile> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <typename T> struct is_reference<T&const volatile> 
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-#else
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-#endif // BOOST_MSVC
-template <typename T> struct is_reference
-{ 
-private:
-   typedef T const volatile cv_t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = 
-      (::boost::type_traits::ice_or<
-      ::boost::type_traits::ice_not<
-         ::boost::is_const<cv_t>::value
-      >::value, 
-      ::boost::type_traits::ice_not<
-         ::boost::is_volatile<cv_t>::value>::value
-      >::value));
-};
-template <> struct is_reference<void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_reference<const void>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <> struct is_reference<volatile void>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <> struct is_reference<const volatile void>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-#endif
-
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-#endif
-
-/**********************************************
- *
- * is_union
- *
- **********************************************/
-template <typename T> struct is_union
-{
-private:
-   typedef typename remove_cv<T>::type cvt;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt));
-};
-
-/**********************************************
- *
- * is_enum
- *
- **********************************************/
-namespace detail{
-struct int_convertible
-{
-   int_convertible(int);
-};
-} // namespace detail
-#ifndef __BORLANDC__
-template <typename T> struct is_enum
-{
-private:
-   typedef typename ::boost::add_reference<T>::type r_type;
-public:
-   BOOST_STATIC_CONSTANT(bool, value =
-      (::boost::type_traits::ice_and<
-         ::boost::type_traits::ice_not< ::boost::is_arithmetic<T>::value>::value,
-         ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
-         ::boost::is_convertible<r_type, detail::int_convertible>::value
-      >::value));
-};
-#else // __BORLANDC__
-//
-// buggy is_convertible prevents working 
-// implementation of is_enum:
-template <typename T> struct is_enum
-{
-public:
-   BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_ENUM(T));
-};
-#endif
-
-/**********************************************
- *
- * is_member_pointer
- *
- **********************************************/
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T> struct is_member_pointer
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T, typename U> struct is_member_pointer<U T::*>
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifdef __GNUC__
-// gcc workaround (JM 02 Oct 2000)
-template <class R, class T>
-struct is_member_pointer<R (T::*)(void)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0>
-struct is_member_pointer<R (T::*)(A0)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1>
-struct is_member_pointer<R (T::*)(A0, A1)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2>
-struct is_member_pointer<R (T::*)(A0, A1, A2)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-struct is_member_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
-#else
-namespace detail{
-template <class R, class T>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(void));
-template <class R, class T, class A0>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0));
-template <class R, class T, class A0, class A1>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1));
-template <class R, class T, class A0, class A1, class A2>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2));
-template <class R, class T, class A0, class A1, class A2, class A3>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28));
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29));
-
-template <class R, class T>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(void) const);
-template <class R, class T, class A0>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0) const);
-template <class R, class T, class A0, class A1>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1) const);
-template <class R, class T, class A0, class A1, class A2>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2) const);
-template <class R, class T, class A0, class A1, class A2, class A3>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28) const);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29) const);
-
-template <class R, class T>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(void) volatile);
-template <class R, class T, class A0>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0) volatile);
-template <class R, class T, class A0, class A1>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1) volatile);
-template <class R, class T, class A0, class A1, class A2>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28) volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29) volatile);
-
-template <class R, class T>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(void) const volatile);
-template <class R, class T, class A0>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0) const volatile);
-template <class R, class T, class A0, class A1>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1) const volatile);
-template <class R, class T, class A0, class A1, class A2>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28) const volatile);
-template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29>
-::boost::type_traits::yes_type is_member_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29) const volatile);
-   no_type is_member_pointer_helper(...);
-}
-template <typename T> 
-struct is_member_pointer
-{ 
-private:
-   static T t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = (1 == sizeof(detail::is_member_pointer_helper(t))) );
-};
-template <> 
-struct is_member_pointer<void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> 
-struct is_member_pointer<const void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <> 
-struct is_member_pointer<volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <> 
-struct is_member_pointer<const volatile void>
-{ 
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#endif
-
-#endif
-
-
-} // namespace boost
-
-#endif // BOOST_COMPOSITE_TYPE_TRAITS_HPP
- 



--- a/include/boost/type_traits/config.hpp
+++ b/include/boost/type_traits/config.hpp
@ -0,0 +1,76 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_CONFIG_HPP_INCLUDED
+#define BOOST_TT_CONFIG_HPP_INCLUDED
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#include <boost/detail/workaround.hpp>
+
+//
+// whenever we have a conversion function with elipses
+// it needs to be declared __cdecl to suppress compiler
+// warnings from MS and Borland compilers (this *must*
+// appear before we include is_same.hpp below):
+#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
+#   define BOOST_TT_DECL __cdecl
+#else
+#   define BOOST_TT_DECL /**/
+#endif
+
+# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000)                         \
+    || BOOST_WORKAROUND(BOOST_MSVC, <= 1301)                        \
+    || !defined(__EDG_VERSION__) && BOOST_WORKAROUND(__GNUC__, < 3) \
+    || BOOST_WORKAROUND(__IBMCPP__, < 600 )                         \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))       \
+    || defined(__ghs)                                               \
+    || BOOST_WORKAROUND(__HP_aCC, BOOST_TESTED_AT(53800))           \
+    || BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890))          \
+    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) )      \
+    && defined(BOOST_NO_IS_ABSTRACT)
+
+#   define BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION 1
+
+#endif
+
+#ifndef BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION
+# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
+#endif
+
+//
+// Define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING 
+// when we can't test for function types with elipsis:
+//
+#if BOOST_WORKAROUND(__GNUC__, < 3)
+#  define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+#endif
+
+//
+// define BOOST_TT_TEST_MS_FUNC_SIGS
+// when we want to test __stdcall etc function types with is_function etc
+// (Note, does not work with Borland, even though it does support __stdcall etc):
+//
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__)
+#  define BOOST_TT_TEST_MS_FUNC_SIGS
+#endif
+
+//
+// define BOOST_TT_NO_CV_FUNC_TEST
+// if tests for cv-qualified member functions don't 
+// work in is_member_function_pointer
+//
+#if BOOST_WORKAROUND(__MWERKS__, < 0x3000) || BOOST_WORKAROUND(__IBMCPP__, <= 600)
+#  define BOOST_TT_NO_CV_FUNC_TEST
+#endif
+
+#endif // BOOST_TT_CONFIG_HPP_INCLUDED
+
+
--- a/include/boost/type_traits/conversion_traits.hpp
+++ b/include/boost/type_traits/conversion_traits.hpp
@ -1,235 +1,17 @@

-// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com)
-// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu)
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright 2000 John Maddock (john@johnmaddock.co.uk)
+// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu)
+// Copyright 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy and use this software is granted, 
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted, 
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

-#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP
-#define BOOST_CONVERSION_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-//
-// is one type convertable to another?
-//
-// there are multiple versions of the is_convertible
-// template, almost every compiler seems to require its
-// own version.
-//
-// Thanks to Andrei Alexandrescu for the original version of the
-// conversion detection technique!
-//
-
-namespace boost{
-
-#ifdef BOOST_MSVC
-
-//
-// MS specific version:
-//
-namespace detail{
-
-   // This workaround is necessary to handle when From is void
-   // which is normally taken care of by the partial specialization
-   // of the is_convertible class.
-   using ::boost::type_traits::yes_type;
-   using ::boost::type_traits::no_type;
-
-  struct from_not_void_conversion {
-    template <class From, class To>
-    struct n_bind {
-      static no_type _m_check(...);
-      static yes_type _m_check(To);
-    public:
-      void foo(); // avoid warning about all members being private
-      static From _m_from;
-      enum { exists = sizeof( _m_check(_m_from) ) == sizeof(yes_type) };
-    };
-  };
-  struct from_is_void_conversion {
-    template <class From, class To>
-    struct n_bind {
-       enum { exists = ::boost::is_void<To>::value };
-    };
-  };
-
-  template <class From>
-  struct conversion_helper {
-    typedef from_not_void_conversion type;
-  };
-  template <>
-  struct conversion_helper<void> {
-    typedef from_is_void_conversion type;
-  };
-} // namespace detail
-
-template <class From, class To>
-struct is_convertible
-{
- typedef typename detail::conversion_helper<From>::type Selector;
- typedef typename Selector::template n_bind<From,To> Conversion;
-public:
- enum { value = Conversion::exists };
-};
-
-#elif defined(__BORLANDC__)
-//
-// special version for Borland compilers
-// this version breaks when used for some
-// UDT conversions:
-//
-template <class From, class To>
-struct is_convertible_helper
-{
-private:
-   // This workaround for Borland breaks the EDG C++ frontend,
-   // so we only use it for Borland.
-   template <class T>
-   struct checker
-   {
-      static type_traits::no_type _m_check(...);
-      static type_traits::yes_type _m_check(T);
-   };
-   static From _m_from;
-public:
-   static const bool value = sizeof( checker<To>::_m_check(_m_from) ) == sizeof(type_traits::yes_type);
-
-   void foo(); // avoid warning about all members being private
-};
-
-template <class From, class To>
-struct is_convertible
-{
-private:
-   typedef is_convertible_helper<From, To> c_type;
-   enum{ v = c_type::value };
-   char force_it[v ? 1 : 2];
-public:
-   static const bool value = is_convertible_helper<From, To>::value;
-};
-
-template <class From>
-struct is_convertible<From, void>
-{
-   static const bool value = false;
-};
-template <class To>
-struct is_convertible<void, To>
-{
-   static const bool value = false;
-};
-template <>
-struct is_convertible<void, void>
-{
-   static const bool value = true;
-};
-
-#elif defined(__GNUC__)
-//
-// special version for gcc compiler
-//
-namespace detail{
-   struct any_conversion
-   {
-      template <class T>
-      any_conversion(const T&);
-      template <class T>
-      any_conversion(T&);
-   };
-   template <class T>
-   struct checker
-   {
-      static boost::type_traits::no_type _m_check(any_conversion ...);
-      static boost::type_traits::yes_type _m_check(T, int);
-   };
-} // namespace detail
-template <class From, class To>
-struct is_convertible
-{
-private:
-   static From _m_from;
-public:
-   static const bool value = sizeof( detail::checker<To>::_m_check(_m_from, 0) ) == sizeof(type_traits::yes_type);
-
-   void foo(); // avoid warning about all members being private
-};
-
-template <class From>
-struct is_convertible<From, void>
-{
-   static const bool value = false;
-};
-template <class To>
-struct is_convertible<void, To>
-{
-   static const bool value = false;
-};
-template <>
-struct is_convertible<void, void>
-{
-   static const bool value = true;
-};
-
-#else
-
-template <class From, class To>
-struct is_convertible
-{
-private:
-   static type_traits::no_type _m_check(...);
-   static type_traits::yes_type _m_check(To);
-   static From _m_from;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = sizeof( _m_check(_m_from) ) == sizeof(type_traits::yes_type));
-   void foo(); // avoid warning about all members being private
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template <class From, class To>
-const bool is_convertible<From, To>::value;
-#endif
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class From>
-struct is_convertible<From, void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class To>
-struct is_convertible<void, To>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <>
-struct is_convertible<void, void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // is_convertible
-
-} // namespace boost
-
-#endif  // include guard
+#ifndef BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED
+#define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED

+#include <boost/type_traits/is_convertible.hpp>

+#endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/cv_traits.hpp
+++ b/include/boost/type_traits/cv_traits.hpp
@ -1,279 +1,24 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 //
 //  defines traits classes for cv-qualified types:
 //  is_const, is_volatile, remove_const, remove_volatile, remove_cv.
-//
-//  Revision History:
-//  24th March 2001:
-//    Fixed is_const/is_volatile so that they work with reference types
-
-#ifndef BOOST_CV_TYPE_TRAITS_HPP
-#define BOOST_CV_TYPE_TRAITS_HPP
-
-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-
-namespace boost{
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-namespace detail{
-//
-// implementation helper:
-//
-template <class T>
-struct cv_traits_imp{};
-
-template <class T>
-struct cv_traits_imp<T*>
-{
-   BOOST_STATIC_CONSTANT(bool, is_const = false);
-   BOOST_STATIC_CONSTANT(bool, is_volatile = false);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<const T*>
-{
-   BOOST_STATIC_CONSTANT(bool, is_const = true);
-   BOOST_STATIC_CONSTANT(bool, is_volatile = false);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<volatile T*>
-{
-   BOOST_STATIC_CONSTANT(bool, is_const = false);
-   BOOST_STATIC_CONSTANT(bool, is_volatile = true);
-   typedef T unqualified_type;
-};
-
-template <class T>
-struct cv_traits_imp<const volatile T*>
-{
-   BOOST_STATIC_CONSTANT(bool, is_const = true);
-   BOOST_STATIC_CONSTANT(bool, is_volatile = true);
-   typedef T unqualified_type;
-};
-
-template <class T, bool is_vol>
-struct remove_const_helper
-{
-   typedef T type;
-};
-template <class T>
-struct remove_const_helper<T, true>
-{
-   typedef volatile T type;
-};
-
-template <class T, bool is_vol>
-struct remove_volatile_helper
-{
-   typedef T type;
-};
-template <class T>
-struct remove_volatile_helper<T, true>
-{
-   typedef const T type;
-};
-
-} // namespace detail
-
-// * convert a type T to a non-volatile type - remove_volatile<T>
-template <typename T>
-struct remove_volatile
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
-   typedef typename detail::remove_volatile_helper<uq_type, ::boost::is_const<T>::value>::type type;
-};
-template <typename T> struct remove_volatile<T&>{ typedef T& type; };
-template <typename T, std::size_t N> struct remove_volatile<volatile T[N]>{ typedef T type[N]; };
-template <typename T, std::size_t N> struct remove_volatile<const volatile T[N]>{ typedef const T type[N]; };
-
-// * convert a type T to non-const type - remove_const<T>
-template <typename T>
-struct remove_const
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
-   typedef typename detail::remove_const_helper<uq_type, ::boost::is_volatile<T>::value>::type type;
-};
-template <typename T> struct remove_const<T&>{ typedef T& type; };
-template <typename T, std::size_t N> struct remove_const<const T[N]>{ typedef T type[N]; };
-template <typename T, std::size_t N> struct remove_const<const volatile T[N]>{ typedef volatile T type[N]; };
-
-//  convert a type T to a non-cv-qualified type - remove_cv<T>
-template <typename T>
-struct remove_cv
-{
-   typedef typename detail::cv_traits_imp<T*>::unqualified_type type;
-};
-template <typename T> struct remove_cv<T&>{ typedef T& type; };
-template <typename T, std::size_t N> struct remove_cv<const T[N]>{ typedef T type[N]; };
-template <typename T, std::size_t N> struct remove_cv<volatile T[N]>{ typedef T type[N]; };
-template <typename T, std::size_t N> struct remove_cv<const volatile T[N]>{ typedef T type[N]; };
-
-//* is a type T  declared const - is_const<T>
-template <typename T>
-struct is_const
-{
-   BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp<T*>::is_const);
-};
-template <typename T> struct is_const<T&>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-#if defined(__BORLANDC__)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct is_const<T&const>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_const<T&volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_const<T&const volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-#endif
-
-//* is a type T declared volatile - is_volatile<T>
-template <typename T>
-struct is_volatile
-{
-   BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp<T*>::is_volatile);
-};
-template <typename T> struct is_volatile<T&>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-#if defined(__BORLANDC__)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T> struct is_volatile<T&const>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_volatile<T&volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <typename T> struct is_volatile<T&const volatile>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-#endif
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-// The following three don't work:
-template <typename T> struct remove_volatile{ typedef T type; };
-template <typename T> struct remove_const{ typedef T type; };
-template <typename T> struct remove_cv{ typedef T type; };
-
-namespace detail{
-   using ::boost::type_traits::yes_type;
-   using ::boost::type_traits::no_type;
-   yes_type is_const_helper(const volatile void*);
-   no_type is_const_helper(volatile void *);
-   yes_type is_volatile_helper(const volatile void*);
-   no_type is_volatile_helper(const void *);
-}
-
-template <typename T>
-struct is_const
-{ 
-private:
-   static T t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(&t))));
-};
-
-template <>
-struct is_const<void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_const<const void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <>
-struct is_const<volatile void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <>
-struct is_const<const volatile void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#endif
-
-template <typename T>
-struct is_volatile
-{
-private:
-   static T t;
-public:
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(&t))));
-};
-
-template <>
-struct is_volatile<void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <>
-struct is_volatile<const void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <>
-struct is_volatile<volatile void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <>
-struct is_volatile<const volatile void>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#endif
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// * convert a type T to const type - add_const<T>
-// this is not required since the result is always
-// the same as "T const", but it does suppress warnings
-// from some compilers:
-template <typename T>
-struct add_const
-{
-   typedef T const type;
-};
-// * convert a type T to volatile type - add_volatile<T>
-// this is not required since the result is always
-// the same as "T volatile", but it does suppress warnings
-// from some compilers:
-template <typename T>
-struct add_volatile
-{
-   typedef T volatile type;
-};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct add_const<T&>{ typedef T& type; };
-template <class T>
-struct add_volatile<T&>{ typedef T& type; };
-#endif
-
-} // namespace boost
-
-
-#endif // BOOST_CV_TYPE_TRAITS_HPP

+#ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED
+#define BOOST_TT_CV_TRAITS_HPP_INCLUDED

+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_volatile.hpp>
+#include <boost/type_traits/add_cv.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_volatile.hpp>
+#include <boost/type_traits/remove_cv.hpp>

+#endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/decay.hpp
+++ b/include/boost/type_traits/decay.hpp
@ -0,0 +1,44 @@
+//  (C) Copyright John Maddock & Thorsten Ottosen 2005.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_DECAY_HPP_INCLUDED
+#define BOOST_TT_DECAY_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/remove_bounds.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost 
+{
+
+    template< class T >
+    struct decay
+    {
+    private:
+        typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type Ty;
+    public:
+        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< 
+            is_array<Ty>,
+            mpl::identity<BOOST_DEDUCED_TYPENAME remove_bounds<Ty>::type*>,
+            BOOST_DEDUCED_TYPENAME mpl::eval_if< 
+                is_function<Ty>,
+                add_pointer<Ty>,
+                mpl::identity<Ty>
+            >
+        >::type type;
+    };
+    
+} // namespace boost
+
+
+#endif // BOOST_TT_DECAY_HPP_INCLUDED
--- a/include/boost/type_traits/detail/bool_trait_def.hpp
+++ b/include/boost/type_traits/detail/bool_trait_def.hpp
@ -0,0 +1,173 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#include <boost/type_traits/detail/template_arity_spec.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/config.hpp>
+
+//
+// Unfortunately some libraries have started using this header without
+// cleaning up afterwards: so we'd better undef the macros just in case 
+// they've been defined already....
+//
+#ifdef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
+#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
+#undef BOOST_TT_AUX_BOOL_C_BASE
+#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
+#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
+#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
+#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
+#endif
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x570)
+#   define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    typedef ::boost::integral_constant<bool,C> type; \
+    enum { value = type::value }; \
+    /**/
+#   define BOOST_TT_AUX_BOOL_C_BASE(C)
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC < 1300
+
+#   define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    typedef ::boost::integral_constant<bool,C> base_; \
+    using base_::value; \
+    /**/
+
+#endif
+
+#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
+#   define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) /**/
+#endif
+
+#ifndef BOOST_TT_AUX_BOOL_C_BASE
+#   define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>
+#endif 
+
+
+#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \
+template< typename T > struct trait \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
+/**/
+
+
+#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) \
+template< typename T1, typename T2 > struct trait \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) \
+template<> struct trait< sp > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) \
+template<> struct trait< sp1,sp2 > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \
+template<> struct trait##_impl< sp > \
+{ \
+    BOOST_STATIC_CONSTANT(bool, value = (C)); \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \
+template<> struct trait##_impl< sp1,sp2 > \
+{ \
+    BOOST_STATIC_CONSTANT(bool, value = (C)); \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) \
+template< param > struct trait< sp > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) \
+template< param1, param2 > struct trait< sp > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
+template< param > struct trait< sp1,sp2 > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) \
+template< param1, param2 > struct trait< sp1,sp2 > \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
+template< param > struct trait##_impl< sp1,sp2 > \
+{ \
+    BOOST_STATIC_CONSTANT(bool, value = (C)); \
+}; \
+/**/
+
+#ifndef BOOST_NO_CV_SPECIALIZATIONS
+#   define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value) \
+    /**/
+#else
+#   define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \
+    /**/
+#endif
--- a/include/boost/type_traits/detail/bool_trait_undef.hpp
+++ b/include/boost/type_traits/detail/bool_trait_undef.hpp
@ -0,0 +1,27 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
+#undef BOOST_TT_AUX_BOOL_C_BASE
+#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
+#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
+#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
+#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
+#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
+#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
--- a/include/boost/type_traits/detail/cv_traits_impl.hpp
+++ b/include/boost/type_traits/detail/cv_traits_impl.hpp
@ -0,0 +1,97 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
+#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+// implementation helper:
+
+
+#if !(BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2))
+namespace boost {
+namespace detail {
+#else
+#include <boost/type_traits/detail/yes_no_type.hpp>
+namespace boost {
+namespace type_traits {
+namespace gcc8503 {
+#endif
+
+template <typename T> struct cv_traits_imp {};
+
+template <typename T>
+struct cv_traits_imp<T*>
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = false);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const T*>
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = true);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<volatile T*>
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = false);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const volatile T*>
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = true);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+    typedef T unqualified_type;
+};
+
+#if BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2)
+// We have to exclude function pointers 
+// (see http://gcc.gnu.org/bugzilla/show_bug.cgi?8503)
+yes_type mini_funcptr_tester(...);
+no_type  mini_funcptr_tester(const volatile void*);
+
+} // namespace gcc8503
+} // namespace type_traits
+
+namespace detail {
+
+// Use the implementation above for non function pointers
+template <typename T, unsigned Select 
+  = (unsigned)sizeof(::boost::type_traits::gcc8503::mini_funcptr_tester((T)0)) >
+struct cv_traits_imp : ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
+
+// Functions are never cv-qualified
+template <typename T> struct cv_traits_imp<T*,1>
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = false);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+    typedef T unqualified_type;
+};
+
+#endif
+
+} // namespace detail
+} // namespace boost 
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
--- a/include/boost/type_traits/detail/false_result.hpp
+++ b/include/boost/type_traits/detail/false_result.hpp
@ -0,0 +1,28 @@
+//  Copyright David Abrahams 2002. 
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED
+#define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_traits {
+
+// Utility class which always "returns" false
+struct false_result
+{
+    template <typename T> struct result_
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+};
+
+}} // namespace boost::type_traits
+
+#endif // BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED
--- a/include/boost/type_traits/detail/ice_and.hpp
+++ b/include/boost/type_traits/detail/ice_and.hpp
@ -0,0 +1,35 @@
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
+#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
+struct ice_and;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_and
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <>
+struct ice_and<true, true, true, true, true, true, true>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
--- a/include/boost/type_traits/detail/ice_eq.hpp
+++ b/include/boost/type_traits/detail/ice_eq.hpp
@ -0,0 +1,36 @@
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
+#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_traits {
+
+template <int b1, int b2>
+struct ice_eq
+{
+    BOOST_STATIC_CONSTANT(bool, value = (b1 == b2));
+};
+
+template <int b1, int b2>
+struct ice_ne
+{
+    BOOST_STATIC_CONSTANT(bool, value = (b1 != b2));
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+template <int b1, int b2> bool const ice_eq<b1,b2>::value;
+template <int b1, int b2> bool const ice_ne<b1,b2>::value;
+#endif
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
--- a/include/boost/type_traits/detail/ice_not.hpp
+++ b/include/boost/type_traits/detail/ice_not.hpp
@ -0,0 +1,31 @@
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
+#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_traits {
+
+template <bool b>
+struct ice_not
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <>
+struct ice_not<true>
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
--- a/include/boost/type_traits/detail/ice_or.hpp
+++ b/include/boost/type_traits/detail/ice_or.hpp
@ -0,0 +1,34 @@
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
+#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
+struct ice_or;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_or
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <>
+struct ice_or<false, false, false, false, false, false, false>
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
--- a/include/boost/type_traits/detail/is_function_ptr_helper.hpp
+++ b/include/boost/type_traits/detail/is_function_ptr_helper.hpp
@ -0,0 +1,220 @@
+
+//  Copyright 2000 John Maddock (john@johnmaddock.co.uk)
+//  Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com)
+//
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED
+#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+
+#if defined(BOOST_TT_PREPROCESSING_MODE)
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/enum_params.hpp>
+#   include <boost/preprocessor/comma_if.hpp>
+#endif
+
+namespace boost {
+namespace type_traits {
+
+template <class R>
+struct is_function_ptr_helper
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+#if !defined(BOOST_TT_PREPROCESSING_MODE)
+// preprocessor-generated part, don't edit by hand!
+
+template <class R >
+struct is_function_ptr_helper<R (*)()> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R >
+struct is_function_ptr_helper<R (*)( ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#else
+
+#undef BOOST_STATIC_CONSTANT
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3, (0, 25, "boost/type_traits/detail/is_function_ptr_helper.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif // BOOST_TT_PREPROCESSING_MODE
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define BOOST_PP_COUNTER BOOST_PP_FRAME_ITERATION(1)
+
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_function_ptr_helper<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))> { BOOST_STATIC_CONSTANT(bool, value = true); };
+@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_function_ptr_helper<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
+@#endif
+#undef BOOST_PP_COUNTER
+#endif // BOOST_PP_IS_ITERATING
--- a/include/boost/type_traits/detail/is_function_ptr_tester.hpp
+++ b/include/boost/type_traits/detail/is_function_ptr_tester.hpp
@ -0,0 +1,654 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 
+//  Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED
+#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED
+
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/config.hpp>
+
+#if defined(BOOST_TT_PREPROCESSING_MODE)
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/enum_params.hpp>
+#   include <boost/preprocessor/comma_if.hpp>
+#endif
+
+namespace boost {
+namespace type_traits {
+
+// Note it is acceptible to use ellipsis here, since the argument will
+// always be a pointer type of some sort (JM 2005/06/04):
+no_type BOOST_TT_DECL is_function_ptr_tester(...);
+
+#if !defined(BOOST_TT_PREPROCESSING_MODE)
+// pre-processed code, don't edit, try GNU cpp with 
+// cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename
+
+template <class R >
+yes_type is_function_ptr_tester(R (*)());
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R >
+yes_type is_function_ptr_tester(R (*)( ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R >
+yes_type is_function_ptr_tester(R (__stdcall*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__stdcall*)( ...));
+#ifndef _MANAGED
+template <class R >
+yes_type is_function_ptr_tester(R (__fastcall*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__fastcall*)( ...));
+#endif
+template <class R >
+yes_type is_function_ptr_tester(R (__cdecl*)());
+template <class R >
+yes_type is_function_ptr_tester(R (__cdecl*)( ...));
+#endif
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (*)( T0));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (*)( T0 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 ...));
+#ifndef _MANAGED
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 ...));
+#endif
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0));
+template <class R , class T0 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 ...));
+#endif
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 ...));
+#endif
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1));
+template <class R , class T0 , class T1 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2));
+template <class R , class T0 , class T1 , class T2 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3));
+template <class R , class T0 , class T1 , class T2 , class T3 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+#endif
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+#ifndef _MANAGED
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+#endif
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
+yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+#endif
+#else
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3, (0, 25, "boost/type_traits/detail/is_function_ptr_tester.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif // BOOST_TT_PREPROCESSING_MODE
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define BOOST_PP_COUNTER BOOST_PP_FRAME_ITERATION(1)
+#undef __stdcall
+#undef __fastcall
+#undef __cdecl
+
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+@#endif
+@#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+@#ifndef _MANAGED
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+@#endif
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
+yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+@#endif
+
+#undef BOOST_PP_COUNTER
+#endif // BOOST_PP_IS_ITERATING
--- a/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
+++ b/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
@ -0,0 +1,817 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 
+//  Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
+#define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_TT_PREPROCESSING_MODE)
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/enum_params.hpp>
+#   include <boost/preprocessor/comma_if.hpp>
+#endif
+
+namespace boost {
+namespace type_traits {
+
+template <typename T>
+struct is_mem_fun_pointer_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+#if !defined(BOOST_TT_PREPROCESSING_MODE)
+// pre-processed code, don't edit, try GNU cpp with 
+// cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+
+#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
+#endif
+
+#else
+
+#undef BOOST_STATIC_CONSTANT
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3, (0, 25, "boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif // BOOST_TT_PREPROCESSING_MODE
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define BOOST_PP_COUNTER BOOST_PP_FRAME_ITERATION(1)
+
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+@#endif
+
+@#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+
+template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
+struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+@#endif
+@#endif
+
+#undef BOOST_PP_COUNTER
+#endif // BOOST_PP_IS_ITERATING
+
--- a/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
+++ b/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
--- a/include/boost/type_traits/detail/size_t_trait_def.hpp
+++ b/include/boost/type_traits/detail/size_t_trait_def.hpp
@ -0,0 +1,58 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#include <boost/type_traits/detail/template_arity_spec.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <cstddef>
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
+#   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
+#else
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::mpl::size_t<C>
+#   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    typedef ::boost::mpl::size_t<C> base_; \
+    using base_::value; \
+    /**/
+#endif
+
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
+template< typename T > struct trait \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+    BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
+/**/
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
+template<> struct trait<spec> \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+    BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
+template< param > struct trait<spec> \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+}; \
+/**/
--- a/include/boost/type_traits/detail/size_t_trait_undef.hpp
+++ b/include/boost/type_traits/detail/size_t_trait_undef.hpp
@ -0,0 +1,16 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1
--- a/include/boost/type_traits/detail/template_arity_spec.hpp
+++ b/include/boost/type_traits/detail/template_arity_spec.hpp
@ -0,0 +1,31 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/aux_/template_arity_fwd.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/config/lambda.hpp>
+#include <boost/mpl/aux_/config/overload_resolution.hpp>
+
+#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
+    && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION)
+#   define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \
+namespace mpl { namespace aux { \
+template< BOOST_MPL_PP_PARAMS(i, typename T) > \
+struct template_arity< \
+          name< BOOST_MPL_PP_PARAMS(i, T) > \
+        > \
+    : int_<i> \
+{ \
+}; \
+}} \
+/**/
+#else
+#   define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/
+#endif
--- a/include/boost/type_traits/detail/type_trait_def.hpp
+++ b/include/boost/type_traits/detail/type_trait_def.hpp
@ -0,0 +1,61 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#include <boost/type_traits/detail/template_arity_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \
+template< typename T > struct trait \
+{ \
+    typedef result type; \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \
+template<> struct trait<spec> \
+{ \
+    typedef result type; \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \
+template<> struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \
+template< param > struct trait<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \
+template< param1, param2 > struct trait<spec> \
+{ \
+    typedef result; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \
+template< param > struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
--- a/include/boost/type_traits/detail/type_trait_undef.hpp
+++ b/include/boost/type_traits/detail/type_trait_undef.hpp
@ -0,0 +1,19 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// $Source$
+// $Date$
+// $Revision$
+
+#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
+#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
+#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
+#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
+#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
+#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
--- a/include/boost/type_traits/detail/wrap.hpp
+++ b/include/boost/type_traits/detail/wrap.hpp
@ -0,0 +1,18 @@
+//  (C) Copyright David Abrahams 2002. 
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
+#define BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
+
+namespace boost {
+namespace type_traits {
+
+template <class T> struct wrap {};
+
+}} // namespace boost::type_traits
+
+#endif // BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
--- a/include/boost/type_traits/detail/yes_no_type.hpp
+++ b/include/boost/type_traits/detail/yes_no_type.hpp
@ -0,0 +1,26 @@
+
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+//
+//  macros and helpers for working with integral-constant-expressions.
+
+#ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
+#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
+
+namespace boost {
+namespace type_traits {
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
--- a/include/boost/type_traits/extent.hpp
+++ b/include/boost/type_traits/extent.hpp
@ -0,0 +1,134 @@
+
+//  (C) Copyright John Maddock 2005.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_EXTENT_HPP_INCLUDED
+#define BOOST_TT_EXTENT_HPP_INCLUDED
+
+// should be the last #include
+#include <boost/type_traits/detail/size_t_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <class T, std::size_t N>
+struct extent_imp
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T[R], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const[R], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T volatile[R], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const volatile[R], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T[R],0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = R);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const[R], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = R);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T volatile[R], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = R);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const volatile[R], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = R);
+};
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) && !defined(__MWERKS__)
+template <class T, std::size_t N>
+struct extent_imp<T[], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+template <class T, std::size_t N>
+struct extent_imp<T const[], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+template <class T, std::size_t N>
+struct extent_imp<T volatile[], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+template <class T, std::size_t N>
+struct extent_imp<T const volatile[], N>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
+};
+template <class T>
+struct extent_imp<T[], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+template <class T>
+struct extent_imp<T const[], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+template <class T>
+struct extent_imp<T volatile[], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+template <class T>
+struct extent_imp<T const volatile[], 0>
+{
+   BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+#endif
+#endif
+}
+
+template <class T, std::size_t N = 0>
+struct extent
+   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) 
+   typedef ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value> base_; 
+   using base_::value;
+#endif
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,extent,(T))
+};
+
+} // namespace boost
+
+#include <boost/type_traits/detail/size_t_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
--- a/include/boost/type_traits/function_traits.hpp
+++ b/include/boost/type_traits/function_traits.hpp
@ -1,148 +1,236 @@

-// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com)
+//  Copyright 2000 John Maddock (john@johnmaddock.co.uk)
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
-// Permission to copy and use this software is granted, 
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted, 
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

-#ifndef BOOST_FUNCTION_TYPE_TRAITS_HPP
-#define BOOST_FUNCTION_TYPE_TRAITS_HPP
+#ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
+#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED

-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#include <boost/type_traits/ice.hpp>
-#endif
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#include <boost/type_traits/fwd.hpp>
-#endif
-#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
-#include <boost/type_traits/composite_traits.hpp>
-#endif
-//
-// is a type a function?
-//
-namespace boost{
-namespace detail{
+#include <boost/config.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+
+namespace boost {

 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+namespace detail {

-template <class R>
-struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = false); };
-template <class R>
-struct is_function_helper_base<R (*)(void)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0>
-struct is_function_helper_base<R (*)(A0)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1>
-struct is_function_helper_base<R (*)(A0, A1)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2>
-struct is_function_helper_base<R (*)(A0, A1, A2)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28>
-struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
+template<typename Function> struct function_traits_helper;

-template <class T>
-struct is_function_helper : is_function_helper_base<T*>{};
+template<typename R>
+struct function_traits_helper<R (*)(void)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 0);
+  typedef R result_type;
+};
+
+template<typename R, typename T1>
+struct function_traits_helper<R (*)(T1)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 1);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T1 argument_type;
+};
+
+template<typename R, typename T1, typename T2>
+struct function_traits_helper<R (*)(T1, T2)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 2);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T1 first_argument_type;
+  typedef T2 second_argument_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3>
+struct function_traits_helper<R (*)(T1, T2, T3)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 3);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+struct function_traits_helper<R (*)(T1, T2, T3, T4)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 4);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 5);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 6);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 7);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 8);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 9);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
+{
+  BOOST_STATIC_CONSTANT(int, arity = 10);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+  typedef T10 arg10_type;
+};
+
+} // end namespace detail
+
+template<typename Function>
+struct function_traits : 
+    public detail::function_traits_helper<typename boost::add_pointer<Function>::type>
+{
+};

 #else

-template <class T>
-struct is_function_helper
+namespace detail {
+
+template<int N> 
+struct type_of_size
 {
-   static T* t;
-   BOOST_STATIC_CONSTANT(bool, value = sizeof(is_function_tester(t)) == sizeof(::boost::type_traits::yes_type));
+  char elements[N];
 };

-#endif
+template<typename R>
+type_of_size<1> function_arity_helper(R (*f)());

-template <class T>
-struct is_function_ref_helper
+template<typename R, typename T1>
+type_of_size<2> function_arity_helper(R (*f)(T1));
+
+template<typename R, typename T1, typename T2>
+type_of_size<3> function_arity_helper(R (*f)(T1, T2));
+
+template<typename R, typename T1, typename T2, typename T3>
+type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
+                                              T9));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
+                                              T9, T10));
+} // end namespace detail
+
+// Won't work with references
+template<typename Function>
+struct function_traits
 {
-   BOOST_STATIC_CONSTANT(bool, value = false);
+  BOOST_STATIC_CONSTANT(int, arity = (sizeof(detail::function_arity_helper((Function*)0))-1));
 };

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template <class T, bool is_ref>
-struct is_function_chooser
-{
-   typedef is_function_helper<T> type;
-};
-template <class T>
-struct is_function_chooser<T, true>
-{
-   typedef is_function_ref_helper<T> type;
-};
-#endif
-} // namespace detail
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}

-template <class T>
-struct is_function
-{
-private:
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   typedef typename detail::is_function_chooser<T, ::boost::is_reference<T>::value>::type m_type;
-#else
-   // without partial specialistaion we can't use is_reference on
-   // function types, that leaves this template broken in the case that
-   // T is a reference:
-   typedef detail::is_function_helper<T> m_type;
-#endif
-public:
-   BOOST_STATIC_CONSTANT(bool, value = m_type::value);
-};
-
-} // boost
-
-#endif // BOOST_FUNCTION_TYPE_TRAITS_HPP
+#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
--- a/include/boost/type_traits/fwd.hpp
+++ b/include/boost/type_traits/fwd.hpp
@ -1,175 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-//  forward declarations of type_traits classes
-//
-#ifndef BOOST_FWD_TYPE_TRAITS_HPP
-#define BOOST_FWD_TYPE_TRAITS_HPP
-
-#include <cstdlib>
-#include <cstddef>
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-//
-// Helper macros for builtin compiler support.
-// If your compiler has builtin support for any of the following
-// traits concepts, then redefine the appropriate macros to pick
-// up on the compiler support:
-//
-// (these should largely ignore cv-qualifiers)
-// BOOST_IS_CLASS(T) should evaluate to true if T is a class or struct type
-// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type
-// BOOST_IS_UNION(T) should evaluate to true if T is a union type
-// BOOST_IS_POD(T) should evaluate to true if T is a POD type
-// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union
-// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
-// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
-// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
-// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
-
-#ifdef BOOST_HAS_SGI_TYPE_TRAITS
-#  define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits<T>::is_POD_type, ::__true_type>::value
-#  define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_default_constructor, ::__true_type>::value
-#  define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_copy_constructor, ::__true_type>::value
-#  define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_assignment_operator, ::__true_type>::value
-#  define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_destructor, ::__true_type>::value
-#endif
-
-#ifndef BOOST_IS_CLASS
-#  define BOOST_IS_CLASS(T) false
-#endif
-
-#ifndef BOOST_IS_ENUM
-#  define BOOST_IS_ENUM(T) false
-#endif
-
-#ifndef BOOST_IS_UNION
-#  define BOOST_IS_UNION(T) false
-#endif
-
-#ifndef BOOST_IS_POD
-#  define BOOST_IS_POD(T) false
-#endif
-
-#ifndef BOOST_IS_EMPTY
-#  define BOOST_IS_EMPTY(T) false
-#endif
-
-#ifndef BOOST_HAS_TRIVIAL_CONSTRUCTOR
-#  define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
-#endif
-
-#ifndef BOOST_HAS_TRIVIAL_COPY
-#  define BOOST_HAS_TRIVIAL_COPY(T) false
-#endif
-
-#ifndef BOOST_HAS_TRIVIAL_ASSIGN
-#  define BOOST_HAS_TRIVIAL_ASSIGN(T) false
-#endif
-
-#ifndef BOOST_HAS_TRIVIAL_DESTRUCTOR
-#  define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
-#endif
-
-
-namespace boost{
-//
-// forward declare all type traits templates here
-//
-// conversion_traits.hpp:
-template <class From, class To>
-struct is_convertible;
-// alignment_traits.hpp:
-template <class T>
-struct alignment_of;
-// arithmetic_traits.hpp:
-template <class T>
-struct is_void;
-template <class T>
-struct is_integral;
-template <class T>
-struct is_float;
-template <class T>
-struct is_arithmetic;
-template <class T>
-struct is_fundamental;
-
-// cv_traits.hpp:
-template <class T>
-struct is_const;
-template <class T>
-struct is_volatile;
-template <class T>
-struct remove_const;
-template <class T>
-struct remove_volatile;
-template <class T>
-struct remove_cv;
-
-// composite_traits.hpp:
-template <class T>
-struct is_array;
-template <class T>
-struct is_pointer;
-template <class T>
-struct is_reference;
-template <class T>
-struct is_member_pointer;
-template <class T>
-struct is_enum;
-template <class T>
-struct is_union;
-
-// object_traits.hpp:
-template <class T>
-struct is_object;
-template <class T>
-struct is_scalar;
-template <class T>
-struct is_class;
-template <class T>
-struct is_compound;
-template <class T>
-struct is_POD;
-template <class T>
-struct has_trivial_constructor;
-template <class T>
-struct has_trivial_copy;
-template <class T>
-struct has_trivial_assign;
-template <class T>
-struct has_trivial_destructor;
-template <class T>
-struct is_empty;
-
-// transform_traits.hpp:
-template <class T>
-struct remove_reference;
-template <class T>
-struct add_reference;
-template <class T>
-struct remove_bounds;
-template <class T>
-struct remove_pointer;
-template <class T>
-struct add_pointer;
-
-// same_traits.hpp:
-template <class T, class U>
-struct is_same;
-
-} // namespace boost
-
-#endif // BOOST_FWD_TYPE_TRAITS_HPP
-
-
-
-
--- a/include/boost/type_traits/has_nothrow_assign.hpp
+++ b/include/boost/type_traits/has_nothrow_assign.hpp
@ -0,0 +1,38 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
+#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_assign.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_assign_imp{
+   BOOST_STATIC_CONSTANT(bool, value = 
+      (::boost::type_traits::ice_or<
+         ::boost::has_trivial_assign<T>::value,
+         BOOST_HAS_NOTHROW_ASSIGN(T)
+      >::value));
+};
+
+}
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_assign,T,::boost::detail::has_nothrow_assign_imp<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
--- a/include/boost/type_traits/has_nothrow_constructor.hpp
+++ b/include/boost/type_traits/has_nothrow_constructor.hpp
@ -0,0 +1,38 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
+#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_constructor.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_constructor_imp{
+   BOOST_STATIC_CONSTANT(bool, value = 
+      (::boost::type_traits::ice_or<
+         ::boost::has_trivial_constructor<T>::value,
+         BOOST_HAS_NOTHROW_CONSTRUCTOR(T)
+      >::value));
+};
+
+}
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_constructor,T,::boost::detail::has_nothrow_constructor_imp<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
--- a/include/boost/type_traits/has_nothrow_copy.hpp
+++ b/include/boost/type_traits/has_nothrow_copy.hpp
@ -0,0 +1,38 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
+#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_copy.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_copy_imp{
+   BOOST_STATIC_CONSTANT(bool, value = 
+      (::boost::type_traits::ice_or<
+         ::boost::has_trivial_copy<T>::value,
+         BOOST_HAS_NOTHROW_COPY(T)
+      >::value));
+};
+
+}
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::detail::has_nothrow_copy_imp<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
--- a/include/boost/type_traits/has_nothrow_destructor.hpp
+++ b/include/boost/type_traits/has_nothrow_destructor.hpp
@ -0,0 +1,25 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
+#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_destructor.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_destructor,T,::boost::has_trivial_destructor<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
--- a/include/boost/type_traits/has_trivial_assign.hpp
+++ b/include/boost/type_traits/has_trivial_assign.hpp
@ -0,0 +1,50 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
+#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_not.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_assign_impl
+{
+   BOOST_STATIC_CONSTANT(bool, value =
+      (::boost::type_traits::ice_and<
+         ::boost::type_traits::ice_or<
+            ::boost::is_pod<T>::value,
+            BOOST_HAS_TRIVIAL_ASSIGN(T)
+         >::value,
+      ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value,
+      ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
+      >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_assign,T,::boost::detail::has_trivial_assign_impl<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
--- a/include/boost/type_traits/has_trivial_constructor.hpp
+++ b/include/boost/type_traits/has_trivial_constructor.hpp
@ -0,0 +1,42 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
+#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_ctor_impl
+{
+   BOOST_STATIC_CONSTANT(bool, value =
+      (::boost::type_traits::ice_or<
+         ::boost::is_pod<T>::value,
+         BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
+      >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_constructor,T,::boost::detail::has_trivial_ctor_impl<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
--- a/include/boost/type_traits/has_trivial_copy.hpp
+++ b/include/boost/type_traits/has_trivial_copy.hpp
@ -0,0 +1,48 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
+#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_not.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_copy_impl
+{
+   BOOST_STATIC_CONSTANT(bool, value =
+      (::boost::type_traits::ice_and<
+         ::boost::type_traits::ice_or<
+            ::boost::is_pod<T>::value,
+            BOOST_HAS_TRIVIAL_COPY(T)
+         >::value,
+      ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
+      >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
--- a/include/boost/type_traits/has_trivial_destructor.hpp
+++ b/include/boost/type_traits/has_trivial_destructor.hpp
@ -0,0 +1,42 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
+#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_dtor_impl
+{
+   BOOST_STATIC_CONSTANT(bool, value =
+      (::boost::type_traits::ice_or<
+         ::boost::is_pod<T>::value,
+         BOOST_HAS_TRIVIAL_DESTRUCTOR(T)
+      >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_destructor,T,::boost::detail::has_trivial_dtor_impl<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
--- a/include/boost/type_traits/has_virtual_destructor.hpp
+++ b/include/boost/type_traits/has_virtual_destructor.hpp
@ -0,0 +1,25 @@
+
+//  (C) Copyright John Maddock 2005.  
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED
+#define BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/intrinsics.hpp>
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_virtual_destructor,T,BOOST_HAS_VIRTUAL_DESTRUCTOR(T))
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
--- a/include/boost/type_traits/ice.hpp
+++ b/include/boost/type_traits/ice.hpp
@ -1,87 +1,20 @@

 //  (C) Copyright John Maddock and Steve Cleary 2000.
-//  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 //
 //  macros and helpers for working with integral-constant-expressions.

-#ifndef BOOST_ICE_TYPE_TRAITS_HPP
-#define BOOST_ICE_TYPE_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-
-namespace boost{
-namespace type_traits{
-
-typedef char yes_type;
-typedef double no_type;
-
-template <bool b>
-struct ice_not
-{ BOOST_STATIC_CONSTANT(bool, value = true); };
-template <>
-struct ice_not<true>
-{ BOOST_STATIC_CONSTANT(bool, value = false); };
-
-template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
-struct ice_or;
-template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
-struct ice_or
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template <>
-struct ice_or<false, false, false, false, false, false, false>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
-struct ice_and;
-template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
-struct ice_and
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template <>
-struct ice_and<true, true, true, true, true, true, true>
-{
-   BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <int b1, int b2>
-struct ice_eq
-{
-   BOOST_STATIC_CONSTANT(bool, value = (b1 == b2));
-};
-
-template <int b1, int b2>
-struct ice_ne
-{
-   BOOST_STATIC_CONSTANT(bool, value = (b1 != b2));
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template <int b1, int b2>
-const bool ice_eq<b1,b2>::value;
-template <int b1, int b2>
-const bool ice_ne<b1,b2>::value;
-#endif
-
-} // namespace type_traits
-
-} // namespace boost
-
-#endif // BOOST_ICE_TYPE_TRAITS_HPP
-
-
-
+#ifndef BOOST_TT_ICE_HPP_INCLUDED
+#define BOOST_TT_ICE_HPP_INCLUDED

+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+#include <boost/type_traits/detail/ice_not.hpp>
+#include <boost/type_traits/detail/ice_eq.hpp>

+#endif // BOOST_TT_ICE_HPP_INCLUDED
--- a/include/boost/type_traits/integral_constant.hpp
+++ b/include/boost/type_traits/integral_constant.hpp
@ -0,0 +1,53 @@
+//  (C) Copyright John Maddock 2005. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
+#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/integral_c.hpp>
+
+namespace boost{
+
+#if defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || defined(__BORLANDC__)
+template <class T, int val>
+#else
+template <class T, T val>
+#endif
+struct integral_constant : public mpl::integral_c<T, val>
+{
+   typedef integral_constant<T,val> type;
+};
+
+template<> struct integral_constant<bool,true> : public mpl::true_ 
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# pragma warning(push)
+# pragma warning(disable:4097)
+   typedef mpl::true_ base_;
+   using base_::value;
+# pragma warning(pop)
+#endif
+   typedef integral_constant<bool,true> type;
+};
+template<> struct integral_constant<bool,false> : public mpl::false_ 
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# pragma warning(push)
+# pragma warning(disable:4097)
+   typedef mpl::false_ base_;
+   using base_::value;
+# pragma warning(pop)
+#endif
+   typedef integral_constant<bool,false> type;
+};
+
+typedef integral_constant<bool,true> true_type;
+typedef integral_constant<bool,false> false_type;
+
+}
+
+#endif
--- a/include/boost/type_traits/intrinsics.hpp
+++ b/include/boost/type_traits/intrinsics.hpp
@ -0,0 +1,137 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED
+#define BOOST_TT_INTRINSICS_HPP_INCLUDED
+
+#ifndef BOOST_TT_CONFIG_HPP_INCLUDED
+#include <boost/type_traits/config.hpp>
+#endif
+
+//
+// Helper macros for builtin compiler support.
+// If your compiler has builtin support for any of the following
+// traits concepts, then redefine the appropriate macros to pick
+// up on the compiler support:
+//
+// (these should largely ignore cv-qualifiers)
+// BOOST_IS_UNION(T) should evaluate to true if T is a union type
+// BOOST_IS_POD(T) should evaluate to true if T is a POD type
+// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union
+// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
+// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
+// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
+// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
+// BOOST_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
+// BOOST_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
+// BOOST_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
+// BOOST_HAS_VIRTUAL_DESTRUCTOR(T) should evaluate to true T has a virtual destructor
+
+#ifdef BOOST_HAS_SGI_TYPE_TRAITS
+    // Hook into SGI's __type_traits class, this will pick up user supplied
+    // specializations as well as SGI - compiler supplied specializations.
+#   include <boost/type_traits/is_same.hpp>
+#   ifdef __NetBSD__
+      // There are two different versions of type_traits.h on NetBSD on Spark
+      // use an implicit include via algorithm instead, to make sure we get
+      // the same version as the std lib:
+#     include <algorithm>
+#   else
+#    include <type_traits.h>
+#   endif
+#   define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits<T>::is_POD_type, ::__true_type>::value
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_default_constructor, ::__true_type>::value
+#   define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_copy_constructor, ::__true_type>::value
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_assignment_operator, ::__true_type>::value
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_destructor, ::__true_type>::value
+
+#   ifdef __sgi
+#      define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#   endif
+#endif
+
+#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
+    // Metrowerks compiler is acquiring intrinsic type traits support
+    // post version 8.  We hook into the published interface to pick up
+    // user defined specializations as well as compiler intrinsics as 
+    // and when they become available:
+#   include <msl_utility>
+#   define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value
+#   define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value
+#   define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value
+#   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
+#if defined(BOOST_MSVC) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >=140050215)
+#   define BOOST_IS_UNION(T) __is_union(T)
+#   define BOOST_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
+#   define BOOST_IS_EMPTY(T) __is_empty(T)
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+#   define BOOST_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+#   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+#   define BOOST_HAS_NOTHROW_COPY(T) __has_nothrow_copy(T)
+#   define BOOST_HAS_NOTHROW_ASSIGN(T) __has_nothrow_assign(T)
+#   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+#   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
+
+#ifndef BOOST_IS_UNION
+#   define BOOST_IS_UNION(T) false
+#endif
+
+#ifndef BOOST_IS_POD
+#   define BOOST_IS_POD(T) false
+#endif
+
+#ifndef BOOST_IS_EMPTY
+#   define BOOST_IS_EMPTY(T) false
+#endif
+
+#ifndef BOOST_HAS_TRIVIAL_CONSTRUCTOR
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
+#endif
+
+#ifndef BOOST_HAS_TRIVIAL_COPY
+#   define BOOST_HAS_TRIVIAL_COPY(T) false
+#endif
+
+#ifndef BOOST_HAS_TRIVIAL_ASSIGN
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) false
+#endif
+
+#ifndef BOOST_HAS_TRIVIAL_DESTRUCTOR
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
+#endif
+
+#ifndef BOOST_HAS_NOTHROW_CONSTRUCTOR
+#   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) false
+#endif
+
+#ifndef BOOST_HAS_NOTHROW_COPY
+#   define BOOST_HAS_NOTHROW_COPY(T) false
+#endif
+
+#ifndef BOOST_HAS_NOTHROW_ASSIGN
+#   define BOOST_HAS_NOTHROW_ASSIGN(T) false
+#endif
+
+#ifndef BOOST_HAS_VIRTUAL_DESTRUCTOR
+#   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) false
+#endif
+
+#endif // BOOST_TT_INTRINSICS_HPP_INCLUDED
+
+
+
+
--- a/Show More
+++ b/Show More