Add OS X to Travis

Merge branch 'develop'
Add .travis.yml
2025-06-25 20:11:56 +02:00 · 2017-11-07 16:13:33 +02:00 · 2017-11-07 16:11:43 +02:00 · 2017-11-07 15:17:15 +02:00 · 2016-10-07 23:07:37 -05:00 · 2016-03-13 08:04:40 +08:00
19 changed files with 1755 additions and 2297 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,111 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/tuple
+  - python tools/boostdep/depinst/depinst.py tuple
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/tuple/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,37 @@
+#   Copyright (c) 2001 Jaakko J<>rvi
+
+#   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)
+
+project doc/tuple ;
+
+import boostbook ;
+import quickbook ;
+
+xml tuple : tuple_users_guide.qbk ;
+
+boostbook standalone_tuple
+    :
+        tuple
+    :
+        <xsl:param>boost.root=../../../..
+        # File name of HTML output:
+        <xsl:param>root.filename=tuple_users_guide
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=0
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=0
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=1
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=1
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=0
+     ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone_tuple ;
+explicit boostrelease ;
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -1,153 +0,0 @@
-<html>
-
-<title>Design decisions rationale for Boost Tuple Library</title>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>Tuple Library : design decisions rationale</h1>
-
-<h2>About namespaces</h2>
-
-<p>
-There was a discussion about whether tuples should be in a separate namespace or directly in the <code>boost</code> namespace.
-The common principle is that domain libraries (like <i>graph</i>, <i>python</i>) should be on a separate
-subnamespace, while utility like libraries directly in the <code>boost</code> namespace.
-Tuples are somewhere in between, as the tuple template is clearly a general utility, but the library introduces quite a lot of names in addition to just the tuple template. 
-Tuples were originally under a subnamespace.
-As a result of the discussion, tuple definitions were moved directly under the <code>boost</code> namespace.
-As a result of a continued discussion, the subnamespace was reintroduced.
-The final (I truly hope so) solution is now to have all definitions in namespace <code>::boost::tuples</code>, and the most common names in the <code>::boost</code> namespace as well. 
-This is accomplished with using declarations (suggested by Dave Abrahams):
-<code><pre>namespace boost {
-  namespace tuples {
-      ...      
-    // All library code
-      ...
-  }
-  using tuples::tuple; 
-  using tuples::make_tuple;
-  using tuples::tie;
-  using tuples::get;
-}
-</pre></code>
-With this arrangement, tuple creation with direct constructor calls, <code>make_tuple</code> or <code>tie</code> functions do not need the namespace qualifier.
-Further, all functions that manipulate tuples are found with Koenig-lookup.
-The only exceptions are the <code>get&lt;N&gt;</code> functions, which are always called with an explicitly qualified template argument, and thus Koenig-lookup does not apply.
-Therefore, get is lifted to <code>::boost</code> namespace with a using declaration.
-Hence, the interface for an application programmer is in practice under the namespace <code>::boost</code>.
-</p>
-<p>
-The other names, forming an interface for library writers (cons lists, metafunctions manipulating cons lists, ...) remain in the subnamespace <code>::boost::tuples</code>.
-Note, that the names <code>ignore</code>, <code>set_open</code>, <code>set_close</code> and <code>set_delimiter</code> are considered to be part of the application programmer's interface, but are still not under <code>boost</code> namespace. 
-The reason being the danger for name clashes for these common names.
-Further, the usage of these features is probably not very frequent.
-</p>
-
-<h4>For those who are really interested in namespaces</h4>
-
-<p>
-The subnamespace name <i>tuples</i> raised some discussion.
-The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template. 
-Namespace names are, however, not generally in plural form in boost libraries. 
-First, no real trouble was reported for using the same name for a namespace and a class and we considered changing the name 'tuples' to 'tuple'.
-But we found some trouble after all.
-Both gcc and edg compilers reject using declarations where the namespace and class names are identical:
-
-<code><pre>namespace boost {
-  namespace tuple {
-    ... tie(...);
-    class tuple; 
-&nbsp;     ...
-  }
-  using tuple::tie; // ok
-  using tuple::tuple; // error
-    ...
-}
-</pre></code>
-
-Note, however, that a corresponding using declaration in the global namespace seems to be ok: 
-
-<code><pre>
-using boost::tuple::tuple; // ok;
-</pre></code>
-
-
-<h2>The end mark of the cons list (nil, null_type, ...)</h2>
-
-<p>
-Tuples are internally represented as <code>cons</code> lists:
-
-<code><pre>tuple&lt;int, int&gt;
-</pre></code> 
-inherits from 
-<code><pre>cons&lt;int, cons&lt;int, null_type&gt; &gt;
-</code></pre>
-
-<code>null_type</code> is the end mark of the list. Original proposition was <code>nil</code>, but the name is used in MacOS, and might have caused problems, so <code>null_type</code> was chosen instead.
-Other names considered were <i>null_t</i> and <i>unit</i> (the empty tuple type in SML).
-<p>
-Note that <code>null_type</code> is the internal representation of an empty tuple: <code>tuple&lt;&gt;</code> inherits from <code>null_type</code>.
-</p>
-
-<h2>Element indexing</h2>
-
-<p>
-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:
-
-<ul>
-<li> 0-based indexing is 'the C++ way' and used with arrays etc.</li>
-<li> 1-based 'name like' indexing exists as well, eg. <code>bind1st</code>, <code>bind2nd</code>, <code>pair::first</code>, etc.</li>
-</ul>
-Tuple access with the syntax <code>get&lt;N&gt;(a)</code>, or <code>a.get&lt;N&gt;()</code> (where <code>a</code> is a tuple and <code>N</code> an index), was considered to be of the first category, hence, the index of the first element in a tuple is 0.
-
-<p>
-A suggestion to provide 1-based 'name like' indexing with constants like <code>_1st</code>, <code>_2nd</code>, <code>_3rd</code>, ... was made.
-By suitably chosen constant types, this would allow alternative syntaxes:
-
-<code><pre>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
-</pre></code>
-
-We chose not to provide more than one indexing method for the following reasons:
-<ul>
-<li>0-based indexing might not please everyone, but once its fixed, it is less confusing than having two different methods (would anyone want such constants for arrays?).</li>
-<li>Adding the other indexing scheme doesn't really provide anything new (like a new feature) to the user of the library.</li>
-<li>C++ variable and constant naming rules don't give many possibilities for defining short and nice index constants (like <code>_1st</code>, ...). 
-Let the binding and lambda libraries use these for a better purpose.</li>
-<li>The access syntax <code>a[_1st]</code> (or <code>a(_1st)</code>) is appealing, and almost made us add the index constants after all. However, 0-based subscripting is so deep in C++, that we had a fear for confusion.</li>
-<li>
-Such constants are easy to add.
-</li>
-</ul>
-
-
-<h2>Tuple comparison</h2>
-
-The comparison operator implements lexicographical order. 
-Other orderings were considered, mainly dominance (<i>a &lt; b iff for each i a(i) < b(i)</i>). 
-Our belief is, that lexicographical ordering, though not mathematically the most natural one, is the most frequently needed ordering in everyday programming.
-
-<h2>Streaming</h2>
-
-<p>
-The characters specified with tuple stream manipulators are stored within the space allocated by <code>ios_base::xalloc</code>, which allocates storage for <code>long</code> type objects.
-<code>static_cast</code> is used in casting between <code>long</code> and the stream's character type. 
-Streams that have character types not convertible back and forth to long thus fail to compile.
-
-This may be revisited at some point. The two possible solutions are:
-<ul>
-<li>Allow only plain <code>char</code> types as the tuple delimiters and use <code>widen</code> and <code>narrow</code> to convert between the real character type of the stream. 
-This would always compile, but some calls to set manipulators might result in a different
-  character than expected (some default character).</li>
-<li>Allocate enough space to hold the real character type of the stream. 
-This means memory for holding the delimiter characters must be allocated separately, and that pointers to this memory are stored in the space allocated with <code>ios_base::xalloc</code>.
-Any volunteers?</li>
-</ul>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr><p>&copy; Copyright Jaakko J&auml;rvi 2001. 
-</body>
-</html>
-
--- a/doc/design_decisions_rationale.qbk
+++ b/doc/design_decisions_rationale.qbk
@ -0,0 +1,190 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[article Design decisions rationale
+  [quickbook 1.6]
+  [id design_decisions_rationale]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+[section About namespaces]
+
+There was a discussion about whether tuples should be in a separate namespace
+or directly in the `boost` namespace. The common principle is that domain
+libraries (like /graph/, /python/) should be on a separate subnamespace, while
+utility like libraries directly in the boost namespace. Tuples are somewhere
+in between, as the tuple template is clearly a general utility, but the
+library introduces quite a lot of names in addition to just the tuple template.
+Tuples were originally under a subnamespace. As a result of the discussion,
+tuple definitions were moved directly under the `boost` namespace. As a result
+of a continued discussion, the subnamespace was reintroduced. The final (I
+truly hope so) solution is now to have all definitions in namespace
+`::boost::tuples`, and the most common names in the `::boost` namespace as well.
+This is accomplished with using declarations (suggested by Dave Abrahams):
+
+    namespace boost {
+      namespace tuples {
+          ...
+        // All library code
+          ...
+      }
+      using tuples::tuple;
+      using tuples::make_tuple;
+      using tuples::tie;
+      using tuples::get;
+    }
+
+With this arrangement, tuple creation with direct constructor calls,
+`make_tuple` or `tie` functions do not need the namespace qualifier. Further,
+all functions that manipulate tuples are found with Koenig-lookup. The only
+exceptions are the `get<N>` functions, which are always called with an
+explicitly qualified template argument, and thus Koenig-lookup does not apply.
+Therefore, `get` is lifted to `::boost` namespace with a using declaration.
+Hence, the interface for an application programmer is in practice under the
+namespace `::boost`.
+
+The other names, forming an interface for library writers (cons lists,
+metafunctions manipulating cons lists, ...) remain in the subnamespace
+`::boost::tuples`. Note, that the names `ignore`, `set_open`, `set_close` and
+`set_delimiter` are considered to be part of the application programmer's
+interface, but are still not under `boost` namespace. The reason being the
+danger for name clashes for these common names. Further, the usage of these
+features is probably not very frequent.
+
+[section For those who are really interested in namespaces]
+
+The subnamespace name /tuples/ raised some discussion. The rationale for not
+using the most natural name 'tuple' is to avoid having an identical name with
+the tuple template. Namespace names are, however, not generally in plural form
+in Boost libraries. First, no real trouble was reported for using the same
+name for a namespace and a class and we considered changing the name 'tuples'
+to 'tuple'. But we found some trouble after all. Both gcc and edg compilers
+reject using declarations where the namespace and class names are identical:
+
+    namespace boost {
+      namespace tuple {
+        ... tie(...);
+        class tuple;
+          ...
+      }
+      using tuple::tie; // ok
+      using tuple::tuple; // error
+        ...
+    }
+
+Note, however, that a corresponding using declaration in the global namespace
+seems to be ok:
+
+    using boost::tuple::tuple; // ok;
+
+[endsect]
+
+[endsect]
+
+[section The end mark of the cons list (`nil`, `null_type`, ...)]
+
+Tuples are internally represented as cons lists:
+
+    tuple<int, int>
+
+inherits from
+
+    cons<int, cons<int, null_type> >
+
+`null_type` is the end mark of the list. Original proposition was `nil`, but
+the name is used in MacOS, and might have caused problems, so `null_type` was
+chosen instead. Other names considered were /null_t/ and /unit/ (the empty
+tuple type in SML).
+
+Note that `null_type` is the internal representation of an empty tuple:
+`tuple<>` inherits from `null_type`.
+
+[endsect]
+
+[section Element indexing]
+
+Whether to use `0`- or `1`-based indexing was discussed more than thoroughly,
+and the following observations were made:
+
+* `0`-based indexing is 'the C++ way' and used with arrays etc.
+
+* `1`-based 'name like' indexing exists as well, eg. `bind1st`, `bind2nd`,
+  `pair::first`, etc.
+
+Tuple access with the syntax `get<N>(a)`, or `a.get<N>()` (where `a` is a
+tuple and `N` an index), was considered to be of the first category, hence,
+the index of the first element in a tuple is `0`.
+
+A suggestion to provide `1`-based 'name like' indexing with constants like
+`_1st`, `_2nd`, `_3rd`, ... was made. By suitably chosen constant types, this
+would allow alternative syntaxes:
+
+    a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
+
+We chose not to provide more than one indexing method for the following
+reasons:
+
+* `0`-based indexing might not please everyone, but once its fixed, it is less
+  confusing than having two different methods (would anyone want such
+  constants for arrays?).
+
+* Adding the other indexing scheme doesn't really provide anything new (like a
+  new feature) to the user of the library.
+
+* C++ variable and constant naming rules don't give many possibilities for
+  defining short and nice index constants (like `_1st`, ...). Let the binding
+  and lambda libraries use these for a better purpose.
+
+* The access syntax a[_1st] (or a(_1st)) is appealing, and almost made us add
+  the index constants after all. However, `0`-based subscripting is so deep in
+  C++, that we had a fear for confusion.
+
+* Such constants are easy to add.
+
+[endsect]
+
+[section Tuple comparison]
+
+The comparison operator implements lexicographical order. Other orderings were
+considered, mainly dominance /(a < b iff for each i a(i) < b(i))/. Our belief
+is, that lexicographical ordering, though not mathematically the most natural
+one, is the most frequently needed ordering in everyday programming.
+
+[endsect]
+
+[section Streaming]
+
+The characters specified with tuple stream manipulators are stored within the
+space allocated by `ios_base::xalloc`, which allocates storage for `long` type
+objects. `static_cast` is used in casting between `long` and the stream's
+character type. Streams that have character types not convertible back and
+forth to long thus fail to compile.
+
+This may be revisited at some point. The two possible solutions are:
+
+* Allow only plain `char` types as the tuple delimiters and use `widen` and
+  `narrow` to convert between the real character type of the stream. This
+  would always compile, but some calls to set manipulators might result in a
+  different character than expected (some default character).
+
+* Allocate enough space to hold the real character type of the stream. This
+  means memory for holding the delimiter characters must be allocated
+  separately, and that pointers to this memory are stored in the space
+  allocated with `ios_base::xalloc`. Any volunteers?
+
+[endsect]
--- a/doc/tuple_advanced_interface.html
+++ b/doc/tuple_advanced_interface.html
@ -1,133 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Tuple library advanced features</title>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-  </head>
-
-  <body>
-    <h1>Tuple library advanced features</h1>
-
-The advanced features described in this document are all under namespace <code>::boost::tuples</code>
-
-<h2>Metafunctions for tuple types</h2>
-<p>
-Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression. 
-
-<code><pre>element&lt;N, T&gt;::type</pre></code>
-
-gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
-</p>
-
-<code><pre>length&lt;T&gt;::value</pre></code>
-
-gives the length of the tuple type <code>T</code>.
-</p>
-
-<h2>Cons lists</h2>
-
-<p>
-Tuples are internally represented as <i>cons lists</i>.
-For example, the tuple 
-
-<code><pre>tuple&lt;A, B, C, D&gt;</pre></code>
-
- inherits from the type
-<code><pre>cons&lt;A, cons&lt;B, cons&lt;C, cons&lt;D, null_type&gt; &gt; &gt; &gt;
-</pre></code>
-
-The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
-<code>tuple&lt;A&gt;::inherited</code> is the type <code>cons&lt;A, null_type&gt;</code>.
-</p>
-
-<h4>Empty tuple</h4>
-<p>
-The internal representation of the empty tuple <code>tuple&lt;&gt</code> is <code>null_type</code>.
-</p>
-
-<h4>Head and tail</h4>
-<p>
-Both tuple template and the cons templates provide the typedefs <code>head_type</code> and <code>tail_type</code>.
-The <code>head_type</code> typedef gives the type of the first element of the tuple (or the cons list).
-The 
-<code>tail_type</code> typedef gives the remaining cons list after removing the first element.
-The head element is stored in the member variable <code>head</code> and the tail list in the member variable <code>tail</code>.
-Cons lists provide the member function <code>get_head()</code> for getting a reference to the head of a cons list, and <code>get_tail()</code> for getting a reference to the tail.
-There are const and non-const versions of both functions.
-</p>
-<p>
-Note that in a one element tuple, <code>tail_type</code> equals <code>null_type</code> and the <code>get_tail()</code> function returns an object of type <code>null_type</code>.
-</p>
-<p>
-The empty tuple (<code>null_type</code>) has no head or tail, hence the <code>get_head</code> and <code>get_tail</code> functions are not provided.
-</p>
-
-<p>
-Treating tuples as cons lists gives a convenient means to define generic functions to manipulate tuples. For example, the following pair of function templates assign 0 to each element of a tuple (obviously, the assignments must be valid operations for the element types):
-
-<pre><code>inline void set_to_zero(const null_type&amp;) {};
-
-template &lt;class H, class T&gt;
-inline void set_to_zero(cons&lt;H, T&gt;&amp; x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
-</code></pre>
-<p>
-
-<h4>Constructing cons lists</h4>
-
-<p>
-A cons list can be default constructed provided that all its elements can be default constructed.
-</p>
-<p>
-A cons list can be constructed from its head and tail. The prototype of the constructor is:
-<pre><code>cons(typename access_traits&lt;head_type&gt;::parameter_type h,
-     const tail_type&amp; t)
-</code></pre>
-The traits template for the head parameter selects correct parameter types for different kinds of element types (for reference elements the parameter type equals the element type, for non-reference types the parameter type is a reference to const non-volatile element type).
-</p>
-<p>
-For a one-element cons list the tail argument (<code>null_type</code>) can be omitted.
-</p>
-
-
-<h2>Traits classes for tuple element types</h2>
-
-<h4><code>access_traits</code></h4>
-<p>
-The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
-<ol>
-<li><code>access_traits&lt;T&gt;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
-<li><code>access_traits&lt;T&gt;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
-<li><code>access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
-</ol>
-<h4><code>make_tuple_traits</code></h4>
-
-The element types of the tuples that are created with the <code>make_tuple</code> functions are computed with the type function <code>make_tuple_traits</code>. 
-The type function call <code>make_tuple_traits&lt;T&gt;::type</code> implements the following type mapping:
-<ul>
-<li><i>any reference type</i> -&gt; <i>compile time error</i>
-</li>
-<li><i>any array type</i> -&gt; <i>constant reference to the array type</i>
-</li>
-<li><code>reference_wrapper&lt;T&gt;</code> -&gt; <code>T&amp;</code>
-</li>
-<li><code>T</code> -&gt; <code>T</code>
-</li>
-</ul>
-
-Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see <A href="tuple_users_guide.html#make_tuple">The <code>make_tuple</code> function</A>.)
-</p>
-
-<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost. 
-The <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate file <code>ref.hpp</code> in the main boost include directory; and directly in the <code>boost</code> namespace.
-</p>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr>
-
-<p>&copy; Copyright Jaakko J&auml;rvi 2001.</p>
-  </body>
-</html>
--- a/doc/tuple_advanced_interface.qbk
+++ b/doc/tuple_advanced_interface.qbk
@ -0,0 +1,159 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[article Tuple library advanced features
+  [quickbook 1.6]
+  [id tuple_advanced_interface]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+The advanced features described in this document are all under namespace
+`::boost::tuples`
+
+[section Metafunctions for tuple types]
+
+Suppose `T` is a tuple type, and `N` is a constant integral expression.
+
+    element<N, T>::type
+
+gives the type of the `N`-th element in the tuple type `T`. If `T` is `const`,
+the resulting type is `const` qualified as well. Note that the constness of `T`
+does not affect reference type elements.
+
+    length<T>::value
+
+gives the length of the tuple type `T`.
+
+[endsect]
+
+[section Cons lists]
+
+Tuples are internally represented as /cons lists/. For example, the tuple
+
+    tuple<A, B, C, D>
+
+inherits from the type
+
+    cons<A, cons<B, cons<C, cons<D, null_type> > > >
+
+The tuple template provides the typedef inherited to access the cons list
+representation. E.g.: `tuple<A>::inherited` is the type `cons<A, null_type>`.
+
+[section Empty tuple]
+
+The internal representation of the empty tuple `tuple<>` is `null_type`.
+
+[endsect]
+
+[section Head and tail]
+
+Both tuple template and the cons templates provide the typedefs `head_type`
+and `tail_type`. The `head_type` typedef gives the type of the first element
+of the tuple (or the cons list). The `tail_type` typedef gives the remaining
+cons list after removing the first element. The head element is stored in the
+member variable `head` and the tail list in the member variable `tail`. Cons
+lists provide the member function `get_head()` for getting a reference to the
+head of a cons list, and `get_tail()` for getting a reference to the tail.
+There are const and non-const versions of both functions.
+
+Note that in a one element tuple, `tail_type` equals `null_type` and the
+`get_tail()` function returns an object of type `null_type`.
+
+The empty tuple (`null_type`) has no head or tail, hence the `get_head` and
+`get_tail` functions are not provided.
+
+Treating tuples as cons lists gives a convenient means to define generic
+functions to manipulate tuples. For example, the following pair of function
+templates assign `0` to each element of a tuple (obviously, the assignments
+must be valid operations for the element types):
+
+    inline void set_to_zero(const null_type&) {};
+
+    template <class H, class T>
+    inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
+
+[endsect]
+
+[section Constructing cons lists]
+
+A cons list can be default constructed provided that all its elements can be
+default constructed.
+
+A cons list can be constructed from its head and tail. The prototype of the
+constructor is:
+
+    cons(typename access_traits<head_type>::parameter_type h, const tail_type& t)
+
+The traits template for the head parameter selects correct parameter types for
+different kinds of element types (for reference elements the parameter type
+equals the element type, for non-reference types the parameter type is a
+reference to const non-volatile element type).
+
+For a one-element cons list the tail argument (`null_type`) can be omitted.
+
+[endsect]
+
+[endsect]
+
+[section Traits classes for tuple element types]
+
+[section access_traits]
+
+The template `access_traits` defines three type functions. Let `T` be a type
+of an element in a tuple:
+
+* `access_traits<T>::non_const_type` maps `T` to the return type of the no
+  n-const access functions (nonmember and member `get` functions, and the
+  `get_head` function).
+
+* `access_traits<T>::const_type` maps `T` to the return type of the const
+  access functions.
+
+* `access_traits<T>::parameter_type` maps `T` to the parameter type of the
+  tuple constructor.
+
+[endsect]
+
+[section make_tuple_traits]
+
+The element types of the tuples that are created with the `make_tuple`
+functions are computed with the type function `make_tuple_traits`. The type
+function call `make_tuple_traits<T>::type` implements the following type
+mapping:
+
+* /any reference type/ -> /compile time error/
+
+* /any array type/ -> /constant reference to the array type/
+
+* `reference_wrapper<T>` -> `T&`
+
+* `T` -> `T`
+
+Objects of type `reference_wrapper` are created with the `ref` and `cref`
+functions (see [link tuple.constructing_tuples.make_tuple The `make_tuple`
+function]).
+
+Reference wrappers were originally part of the tuple library, but they are now
+a general utility of boost. The `reference_wrapper` template and the `ref` and
+`cref` functions are defined in a separate file
+[@boost:/libs/core/doc/html/core/ref.html `ref.hpp`] in the main boost include
+directory; and directly in the `boost` namespace.
+
+[endsect]
+
+[endsect]
--- a/doc/tuple_users_guide.html
+++ b/doc/tuple_users_guide.html
@ -1,529 +0,0 @@
-<html>
-<head>
-<title>The Boost Tuple Library</title>
-</head>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>The Boost Tuple Library</h1>
-
-<p>
-A tuple (or <i>n</i>-tuple) is a fixed size collection of elements. 
-Pairs, triples, quadruples etc. are tuples. 
-In a programming language, a tuple is a data object containing other objects as elements. 
-These element objects may be of different types.
-</p>
-
-<p>Tuples are convenient in many circumstances. 
-For instance, tuples make it easy to define functions that return more than one value.
-</p>
-
-<p>
-Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. 
-Unfortunately C++ does not.
-To compensate for this &quot;deficiency&quot;, the Boost Tuple Library implements a tuple construct using templates.
-</p>
-
-<h2>Table of Contents</h2>
-
-<ol>
-<li><a href = "#using_library">Using the library</a></li>
-<li><a href = "#tuple_types">Tuple types</a></li>
-<li><a href = "#constructing_tuples">Constructing tuples</a></li>
-<li><a href = "#accessing_elements">Accessing tuple elements</a></li>
-<li><a href = "#construction_and_assignment">Copy construction and tuple assignment</a></li>
-<li><a href = "#relational_operators">Relational operators</a></li>
-<li><a href = "#tiers">Tiers</a></li>
-<li><a href = "#streaming">Streaming</a></li>
-<li><a href = "#performance">Performance</a></li>
-<li><a href = "#portability">Portability</a></li>
-<li><a href = "#thanks">Acknowledgements</a></li>
-<li><a href = "#references">References</a></li>
-</ol>
-
-<h4>More details</h4>
-
-<p>
-<a href = "tuple_advanced_interface.html">Advanced features</a> (describes some metafunctions etc.).</p>
-<p>
-<a href = "design_decisions_rationale.html">Rationale behind some design/implementation decisions.</a></p>
-
-
-<h2><a name="using_library">Using the library</a></h2>
-
-<p>To use the library, just include:
-
-<pre><code>#include &quot;boost/tuple/tuple.hpp&quot;</code></pre>
-
-<p>Comparison operators can be included with:
-<pre><code>#include &quot;boost/tuple/tuple_comparison.hpp&quot;</code></pre>
-
-<p>To use tuple input and output operators,
-
-<pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
-
-Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
-
-<p>All definitions are in namespace <code>::boost::tuples</code>, but the most common names are lifted to namespace <code>::boost</code> with using declarations. These names are: <code>tuple</code>, <code>make_tuple</code>, <code>tie</code> and <code>get</code>. Further, <code>ref</code> and <code>cref</code> are defined directly under the <code>::boost</code> namespace.
-
-<h2><a name = "tuple_types">Tuple types</a></h2>
-
-<p>A tuple type is an instantiation of the <code>tuple</code> template. 
-The template parameters specify the types of the tuple elements.
-The current version supports tuples with 0-10 elements. 
-If necessary, the upper limit can be increased up to, say, a few dozen elements.
-The data element can be any C++ type.
-Note that <code>void</code> and plain function types are valid 
-C++ types, but objects of such types cannot exist. 
-Hence, if a tuple type contains such types as elements, the tuple type
-can exist, but not an object of that type.
-There are natural limitations for element types that cannot
-be be copied, or that are not default constructible (see 'Constructing tuples'
- below). 
-
-<p>
-For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
-
-<pre><code>tuple&lt;int&gt;
-tuple&lt;double&amp;, const double&amp;, const double, double*, const double*&gt;
-tuple&lt;A, int(*)(char, int), B(A::*)(C&amp;), C&gt;
-tuple&lt;std::string, std::pair&lt;A, B&gt; &gt;
-tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
-</code></pre>
-
-<h2><a name = "constructing_tuples">Constructing tuples</a></h2>
-
-<p>
-The tuple constructor takes the tuple elements as arguments. 
-For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt; <i>k</i> &lt;= <i>n</i>.
-For example:
-<pre><code>tuple&lt;int, double&gt;() 
-tuple&lt;int, double&gt;(1) 
-tuple&lt;int, double&gt;(1, 3.14)
-</code></pre>
-
-<p>
-If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
-For example.
-
-<pre><code>class X {
-  X(); 
-public:
-  X(std::string);
-};
-
-tuple&lt;X,X,X&gt;()                                              // error: no default constructor for X
-tuple&lt;X,X,X&gt;(string(&quot;Jaba&quot;), string(&quot;Daba&quot;), string(&quot;Duu&quot;)) // ok
-</code></pre>
-
-In particular, reference types do not have a default initialization: 
-
-<pre><code>tuple&lt;double&amp;&gt;()                // error: reference must be 
-                                // initialized explicitly
-
-double d = 5; 
-tuple&lt;double&amp;&gt;(d)               // ok
-
-tuple&lt;double&amp;&gt;(d+3.14)          // error: cannot initialize 
-                                // non-const reference with a temporary
-
-tuple&lt;const double&amp;&gt;(d+3.14)    // ok, but dangerous: 
-                                // the element becomes a dangling reference 
-</code></pre>
-
-<p>Using an initial value for an element that cannot be copied, is a compile
-time error:
-
-<pre><code>class Y { 
-  Y(const Y&amp;); 
-public:
-  Y();
-};
-
-char a[10];
-
-tuple&lt;char[10], Y&gt;(a, Y()); // error, neither arrays nor Y can be copied
-tuple&lt;char[10], Y&gt;();       // ok
-</code></pre>
-
-Note particularly that the following is perfectly ok:
-<code><pre>Y y;
-tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
-</code></pre>
-
-It is possible to come up with a tuple type that cannot be constructed.
-This occurs if an element that cannot be initialized has a lower
-index than an element that requires initialization. 
-For example: <code>tuple&lt;char[10], int&amp;&gt;</code>.
-
-<p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
-</p>
-
-<h4><a name="make_tuple">The <code>make_tuple</code> function</a></h4>
-
-<p>
-Tuples can also be constructed using the <code>make_tuple</code> (cf. <code>std::make_pair</code>) helper functions.
-This makes the construction more convenient, saving the programmer from explicitly specifying the element types: 
-<pre><code>tuple&lt;int, int, double&gt; add_multiply_divide(int a, int b) {
-  return make_tuple(a+b, a*b, double(a)/double(b));
-}
-</code></pre>
-
-<p>
-By default, the element types are deduced to the plain non-reference types. E.g: 
-<pre><code>void foo(const A&amp; a, B&amp; b) { 
-  ...
-  make_tuple(a, b);
-</code></pre>
-The <code>make_tuple</code> invocation results in a tuple of type <code>tuple&lt;A, B&gt;</code>.
-
-<p>
-Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. 
-Therefore, the programmer can control the type deduction and state that a reference to const or reference to
-non-const type should be used as the element type instead.
-This is accomplished with two helper template functions: <code>ref</code> and <code>cref</code>. 
-Any argument can be wrapped with these functions to get the desired type. 
-The mechanism does not compromise const correctness since a const object wrapped with <code>ref</code> results in a tuple element with const reference type (see the fifth code line below).
-For example:
-
-<pre><code>A a; B b; const A ca = a;
-make_tuple(cref(a), b);      // creates tuple&lt;const A&amp;, B&gt;
-make_tuple(ref(a), b);       // creates tuple&lt;A&amp;, B&gt;
-make_tuple(ref(a), cref(b)); // creates tuple&lt;A&amp;, const B&amp;&gt;
-make_tuple(cref(ca));        // creates tuple&lt;const A&amp;&gt;
-make_tuple(ref(ca));         // creates tuple&lt;const A&amp;&gt;
-</code></pre>
-
-
-<p>
-Array arguments to <code>make_tuple</code> functions are deduced to reference to const types by default; there is no need to wrap them with <code>cref</code>. For example:
-<pre><code>make_tuple(&quot;Donald&quot;, &quot;Daisy&quot;);
-</code></pre>
-
-This creates an object of type <code>tuple&lt;const char (&amp;)[5], const char (&amp;)[6]&gt;</code> 
-(note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
-However, to get <code>make_tuple</code> to create a tuple with an element of a
-non-const array type one must use the <code>ref</code> wrapper.
-
-<p>
-Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. 
-A tuple can also hold a reference to a function, 
-but such a tuple cannot be constructed with <code>make_tuple</code> (a const qualified function type would result, which is illegal):
-<pre><code>void f(int i);
-  ...
-make_tuple(&amp;f); // tuple&lt;void (*)(int)&gt;
-  ...
-tuple&lt;tuple&lt;void (&amp;)(int)&gt; &gt; a(f) // ok
-make_tuple(f);                    // not ok
-</code></pre>
-
-<h2><a name = "accessing_elements">Accessing tuple elements</a></h2>
-
-<p>
-Tuple elements are accessed with the expression:
-
-<pre><code>t.get&lt;N&gt;()
-</code></pre>
-or
-<pre><code>get&lt;N&gt;(t)
-</code></pre>
-where <code>t</code> is a tuple object and <code>N</code> is a constant integral expression specifying the index of the element to be accessed.
-Depending on whether <code>t</code> is const or not, <code>get</code> returns the <code>N</code>th element as a reference to const or
-non-const type.
-The index of the first element is 0 and thus<code>
-N</code> must be between 0 and <code>k-1</code>, where <code>k</code> is the number of elements in the tuple. 
-Violations of  these constrains are detected at compile time. Examples:
-
-<pre><code>double d = 2.7; A a;
-tuple&lt;int, double&amp;, const A&amp;&gt; t(1, d, a);
-const tuple&lt;int, double&amp;, const A&amp;&gt; ct = t;
-  ...
-int i = get&lt;0&gt;(t); i = t.get&lt;0&gt;();        // ok
-int j = get&lt;0&gt;(ct);                       // ok
-get&lt;0&gt;(t) = 5;                            // ok 
-get&lt;0&gt;(ct) = 5;                           // error, can't assign to const 
-  ...
-double e = get&lt;1&gt;(t); // ok   
-get&lt;1&gt;(t) = 3.14;     // ok 
-get&lt;2&gt;(t) = A();      // error, can't assign to const 
-A aa = get&lt;3&gt;(t);     // error: index out of bounds 
-  ...
-++get&lt;0&gt;(t);  // ok, can be used as any variable
-</code></pre>
-
-Note! The member get functions are not supported with MS Visual C++ compiler.
-Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier. 
-Hence, all <code>get</code> calls should be qualified as: <code>tuples::get&lt;N&gt;(a_tuple)</code> when writing code that shoud compile with MSVC++ 6.0.
-
-<h2><a name = "construction_and_assignment">Copy construction and tuple assignment</a></h2>
-
-<p>
-A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible.
-Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
-For example:
-
-<pre><code>class A;
-class B : public A {};
-struct C { C(); C(const B&amp;); }
-struct D { operator C() const; }
-tuple&lt;char, B*, B, D&gt; t;
-  ...
-tuple&lt;int, A*, C, C&gt; a(t); // ok 
-a = t;                     // ok 
-</code></pre>
-
-In both cases, the conversions performed are: <code>char -> int</code>, <code>B* -> A*</code> (derived class pointer to base class pointer),  <code>B -> C</code> (a user defined conversion) and <code>D -> C</code> (a user defined conversion).
-
-<p>
-Note that assignment is also defined from <code>std::pair</code> types:
-
-<pre><code>tuple&lt;float, int&gt; a = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "relational_operators">Relational operators</a></h2>
-<p>
-Tuples reduce the operators <code>==, !=, &lt;, >, &lt;=</code> and <code>>=</code> to the corresponding elementary operators. 
-This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well.
-
-The equality operators for two tuples <code>a</code> and <code>b</code> are defined as:
-<ul>
-<li><code>a == b</code> iff for each <code>i</code>: <code>a<sub>i</sub> == b<sub>i</sub></code></li>
-<li><code>a != b</code> iff exists <code>i</code>: <code>a<sub>i</sub> != b<sub>i</sub></code></li>
-</ul>
-
-The operators <code>&lt;, >, &lt;=</code> and <code>>=</code> implement a lexicographical ordering.
-
-<p>
-Note that an attempt to compare two tuples of different lengths results in a compile time error.</p>
-Also, the comparison operators are <i>"short-circuited"</i>: elementary comparisons start from the first elements and are performed only until the result is clear.
-
-<p>Examples:
-
-<pre><code>tuple&lt;std::string, int, A&gt; t1(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t2(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t3(std::string(&quot;different&quot;), 3, A());
-
-bool operator==(A, A) { std::cout &lt;&lt; &quot;All the same to me...&quot;; return true; }
-
-t1 == t2; 		// true
-t1 == t3;               // false, does not print &quot;All the...&quot;
-</code></pre>
-
-
-<h2><a name = "tiers">Tiers</a></h2>
-
-<p>
-<i>Tiers</i> are tuples, where all elements are of non-const reference types.
-They are constructed with a call to the <code>tie</code> function template (cf. <code>make_tuple</code>):
-
-<pre><code>int i; char c; double d; 
-  ...
-tie(i, c, a);
-</code></pre>
-
-<p>
-The above <code>tie</code> function creates a tuple of type <code>tuple&lt;int&amp;, char&amp;, double&amp;&gt;</code>. 
-The same result could be achieved with the call <code>make_tuple(ref(i), ref(c), ref(a))</code>.
-</p>
-
-<p>
-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
-
-<pre><code>int i; char c; double d; 
-tie(i, c, d) = make_tuple(1,'a', 5.5);
-std::cout &lt;&lt; i &lt;&lt; &quot; &quot; &lt;&lt;  c &lt;&lt; &quot; &quot; &lt;&lt; d;
-</code></pre>
-This code prints <code>1 a 5.5</code> to the standard output stream.
-
-A tuple unpacking operation like this is found for example in ML and Python. 
-It is convenient when calling functions which return tuples.
-
-<p>
-The tying mechanism works with <code>std::pair</code> templates as well:
-
-<pre><code>int i; char c;
-tie(i, c) = std::make_pair(1, 'a');
-</code></pre>
-<h4>Ignore</h4>
-There is also an object called <code>ignore</code> which allows you to ignore an element assigned by a tuple.
-The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that <code>ignore</code> is under the <code>tuples</code> subnamespace):
-
-<pre><code>char c;
-tie(tuples::ignore, c) = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "streaming">Streaming</a></h2>
-
-<p>
-The global <code>operator&lt;&lt;</code> has been overloaded for <code>std::ostream</code> such that tuples are 
-output by recursively calling <code>operator&lt;&lt;</code> for each element. 
-</p>
-
-<p>
-Analogously, the global <code>operator&gt;&gt;</code> has been overloaded to extract tuples from <code>std::istream</code>  by recursively calling <code>operator&gt;&gt;</code> for each element. 
-</p>
-
-<p>
-The default delimiter between the elements is space, and the tuple is enclosed
-in parenthesis.
-For Example:
-
-<pre><code>tuple&lt;float, int, std::string&gt; a(1.0f,  2, std::string(&quot;Howdy folks!&quot;);
-
-cout &lt;&lt; a; 
-</code></pre>
-outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>
-
-<p>
-The library defines three <i>manipulators</i> for changing the default behavior:
-<ul>
-<li><code>set_open(char)</code> defines the character that is output before the first
-element.</li>
-<li><code>set_close(char)</code> defines the character that is output after the
-last element.</li>
-<li><code>set_delimiter(char)</code> defines the delimiter character between
-elements.</li>
-</ul>
-
-Note, that these manipulators are defined in the <code>tuples</code> subnamespace. 
-For example:
-<code><pre>cout &lt;&lt; tuples::set_open('[') &lt;&lt; tuples::set_close(']') &lt;&lt; tuples::set_delimiter(',') &lt;&lt; a; 
-</code></pre>
-outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code>
-
-<p>The same manipulators work with <code>operator&gt;&gt;</code> and <code>istream</code> as well. Suppose the <code>cin</code> stream contains the following data:
-
-<pre><code>(1 2 3) [4:5]</code></pre>
-
-The code:
-
-<code><pre>tuple&lt;int, int, int&gt; i;
-tuple&lt;int, int&gt; j;
-
-cin &gt;&gt; i;
-cin &gt;&gt; tuples::set_open('[') &gt;&gt; tuples::set_close(']') &gt;&gt; tules::set_delimiter(':');
-cin &gt;&gt; j;
-</code></pre>
-
-reads the data into the tuples <code>i</code> and <code>j</code>.
-
-<p>
-Note that extracting tuples with <code>std::string</code> or C-style string
-elements does not generally work, since the streamed tuple representation may not be unambiguously
-parseable.
-</p>
-
-<h2><a name = "performance">Performance</a></h2>
-
-All tuple access and construction functions are small inlined one-liners. 
-Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand written tuple like classes. 
-Particularly, with a decent compiler there is no performance difference between this code:
-
-<pre><code>class hand_made_tuple { 
-  A a; B b; C c;
-public:
-  hand_made_tuple(const A&amp; aa, const B&amp; bb, const C&amp; cc) 
-    : a(aa), b(bb), c(cc) {};
-  A&amp; getA() { return a; };
-  B&amp; getB() { return b; };
-  C&amp; getC() { return c; };
-};
-
-hand_made_tuple hmt(A(), B(), C()); 
-hmt.getA(); hmt.getB(); hmt.getC();
-</code></pre>
-
-and this code:
-
-<pre><code>tuple&lt;A, B, C&gt; t(A(), B(), C());
-t.get&lt;0&gt;(); t.get&lt;1&gt;(); t.get&lt;2&gt;(); 
-</code></pre>
-
-<p>Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.
-</p>  
-<p>
-Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using
-non-const reference parameters as a mechanism for returning multiple values from a function. 
-For example, suppose that the following functions <code>f1</code> and <code>f2</code> have equivalent functionalities:
-
-<pre><code>void f1(int&amp;, double&amp;);
-tuple&lt;int, double&gt; f2();
-</code></pre>
-
-Then, the call #1 may be slightly faster than #2 in the code below:
-
-<pre><code>int i; double d;
-  ...
-f1(i,d);         // #1
-tie(i,d) = f2(); // #2
-</code></pre>
-See 
-[<a href=#publ_1>1</a>,
-<a href=#publ_2>2</a>]
- for more in-depth discussions about efficiency.
-
-<h4>Effect on Compile Time</h4>
-
-<p>
-Compiling tuples can be slow due to the excessive amount of template instantiations.
-Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the <code>hand_made_tuple</code> class above.
-However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable.
-Compile time increases between 5 to 10 percentages were measured for programs which used tuples very frequently.
-With the same test programs, memory consumption of compiling increased between 22% to 27%. See  
-[<a href=#publ_1>1</a>,
-<a href=#publ_2>2</a>]
-for details.
-</p>
-
-<h2><a name = "portability">Portability</a></h2>
-
-<p>The library code is(?) standard C++ and thus the library works with a standard conforming compiler. 
-Below is a list of compilers and known problems with each compiler:
-</p>
-<table>
-<tr><td><u>Compiler</u></td><td><u>Problems</u></td></tr>
-<tr><td>gcc 2.95</td><td>-</td></tr>
-<tr><td>edg 2.44</td><td>-</td></tr>
-<tr><td>Borland 5.5</td><td>Can't use function  pointers or member pointers as tuple elements</td></tr>
-<tr><td>Metrowerks 6.2</td><td>Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-<tr><td>MS Visual C++</td><td>No reference elements (<code>tie</code> still works). Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-</table>
-
-<h2><a name = "thanks">Acknowledgements</a></h2>
-Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
-The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
-library.
-The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
-<h2><a name = "references">References</a></h2>
-
-<p>
-<a name="publ_1"></a>[1]
-J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
-</p>
-
-<p>
-<a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
-</p>
-
-<p>
-[3] J&auml;rvi J.:<i>Tuple Types and Multiple Return Values</i>, C/C++ Users Journal, August 2001.
-</p>
-
-<hr>
-
-<p>Last modified 2001-09-13</p>
-
-<p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
-
-Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. 
-This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.
-</p>
-</body>
-</html>
-
-
-
-
--- a/doc/tuple_users_guide.qbk
+++ b/doc/tuple_users_guide.qbk
@ -0,0 +1,525 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[library Boost.Tuple
+  [quickbook 1.6]
+  [id tuple]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [dirname tuple]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[include tuple_advanced_interface.qbk]
+[include design_decisions_rationale.qbk]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples,
+quadruples etc. are tuples. In a programming language, a tuple is a data
+object containing other objects as elements. These element objects may be of
+different types.
+
+Tuples are convenient in many circumstances. For instance, tuples make it easy
+to define functions that return more than one value.
+
+Some programming languages, such as ML, Python and Haskell, have built-in
+tuple constructs. Unfortunately C++ does not. To compensate for this
+"deficiency", the Boost Tuple Library implements a tuple construct using
+templates.
+
+[section:using_library Using the Library]
+
+To use the library, just include:
+
+    #include "boost/tuple/tuple.hpp"
+
+Comparison operators can be included with:
+
+    #include "boost/tuple/tuple_comparison.hpp"
+
+To use tuple input and output operators,
+
+    #include "boost/tuple/tuple_io.hpp"
+
+Both `tuple_io.hpp` and `tuple_comparison.hpp` include `tuple.hpp`.
+
+All definitions are in namespace `::boost::tuples`, but the most common names
+are lifted to namespace `::boost` with using declarations. These names are:
+`tuple`, `make_tuple`, `tie` and `get`. Further, `ref` and `cref` are defined
+directly under the `::boost` namespace.
+
+[endsect]
+
+[section:tuple_types Tuple Types]
+
+A tuple type is an instantiation of the `tuple` template. The template
+parameters specify the types of the tuple elements. The current version
+supports tuples with 0-10 elements. If necessary, the upper limit can be
+increased up to, say, a few dozen elements. The data element can be any C++
+type. Note that `void` and plain function types are valid C++ types, but
+objects of such types cannot exist. Hence, if a tuple type contains such types
+as elements, the tuple type can exist, but not an object of that type. There
+are natural limitations for element types that cannot be copied, or that are
+not default constructible (see [link tuple.constructing_tuples 'Constructing tuples']
+below).
+
+For example, the following definitions are valid tuple instantiations (`A`,
+`B` and `C` are some user defined classes):
+
+    tuple<int>
+    tuple<double&, const double&, const double, double*, const double*>
+    tuple<A, int(*)(char, int), B(A::*)(C&), C>
+    tuple<std::string, std::pair<A, B> >
+    tuple<A*, tuple<const A*, const B&, C>, bool, void*>
+
+[endsect]
+
+[section:constructing_tuples Constructing Tuples]
+
+The tuple constructor takes the tuple elements as arguments. For an /n/-
+element tuple, the constructor can be invoked with /k/ arguments, where
+`0` <= /k/ <= /n/. For example:
+
+    tuple<int, double>()
+    tuple<int, double>(1)
+    tuple<int, double>(1, 3.14)
+
+If no initial value for an element is provided, it is default initialized
+(and hence must be default initializable). For example:
+
+    class X {
+      X();
+    public:
+      X(std::string);
+    };
+
+    tuple<X,X,X>()                                              // error: no default constructor for X
+    tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
+
+In particular, reference types do not have a default initialization:
+
+    tuple<double&>()                // error: reference must be
+                                    // initialized explicitly
+
+    double d = 5;
+    tuple<double&>(d)               // ok
+
+    tuple<double&>(d+3.14)          // error: cannot initialize
+                                    // non-const reference with a temporary
+
+    tuple<const double&>(d+3.14)    // ok, but dangerous:
+                                    // the element becomes a dangling reference
+
+Using an initial value for an element that cannot be copied, is a compile time
+error:
+
+    class Y {
+      Y(const Y&);
+    public:
+      Y();
+    };
+
+    char a[10];
+
+    tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
+    tuple<char[10], Y>();       // ok
+
+Note particularly that the following is perfectly ok:
+
+    Y y;
+    tuple<char(&)[10], Y&>(a, y);
+
+It is possible to come up with a tuple type that cannot be constructed. This
+occurs if an element that cannot be initialized has a lower index than an
+element that requires initialization. For example: `tuple<char[10], int&>`.
+
+In sum, the tuple construction is semantically just a group of individual
+elementary constructions.
+
+[section:make_tuple The `make_tuple` function]
+
+Tuples can also be constructed using the `make_tuple` (cf. `std::make_pair`)
+helper functions. This makes the construction more convenient, saving the
+programmer from explicitly specifying the element types:
+
+    tuple<int, int, double> add_multiply_divide(int a, int b) {
+      return make_tuple(a+b, a*b, double(a)/double(b));
+    }
+
+By default, the element types are deduced to the plain non-reference types.
+E.g.:
+
+    void foo(const A& a, B& b) {
+      ...
+      make_tuple(a, b);
+
+The `make_tuple` invocation results in a tuple of type `tuple<A, B>`.
+
+Sometimes the plain non-reference type is not desired, e.g. if the element
+type cannot be copied. Therefore, the programmer can control the type
+deduction and state that a reference to const or reference to non-const type
+should be used as the element type instead. This is accomplished with two
+helper template functions: [@boost:/libs/core/doc/html/core/ref.html `boost::ref`]
+and [@boost:/libs/core/doc/html/core/ref.html `boost::cref`]. Any argument can
+be wrapped with these functions to get the desired type. The mechanism does
+not compromise const correctness since a const object wrapped with ref results
+in a tuple element with const reference type (see the fifth example below).
+For example:
+
+    A a; B b; const A ca = a;
+    make_tuple(cref(a), b);      // creates tuple<const A&, B>
+    make_tuple(ref(a), b);       // creates tuple<A&, B>
+    make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
+    make_tuple(cref(ca));        // creates tuple<const A&>
+    make_tuple(ref(ca));         // creates tuple<const A&>
+
+Array arguments to `make_tuple` functions are deduced to reference to const
+types by default; there is no need to wrap them with `cref`. For example:
+
+    make_tuple("Donald", "Daisy");
+
+This creates an object of type `tuple<const char (&)[7], const char (&)[6]>`
+(note that the type of a string literal is an array of const characters, not
+`const char*`). However, to get `make_tuple` to create a tuple with an element
+of a non-const array type one must use the `ref` wrapper.
+
+Function pointers are deduced to the plain non-reference type, that is, to
+plain function pointer. A tuple can also hold a reference to a function, but
+such a tuple cannot be constructed with `make_tuple` (a const qualified
+function type would result, which is illegal):
+
+    void f(int i);
+      ...
+    make_tuple(&f); // tuple<void (*)(int)>
+      ...
+    tuple<tuple<void (&)(int)> > a(f) // ok
+    make_tuple(f);                    // not ok
+
+[endsect]
+
+[endsect]
+
+[section:accessing_elements Accessing Tuple Elements]
+
+Tuple elements are accessed with the expression:
+
+    t.get<N>()
+
+or
+
+    get<N>(t)
+
+where `t`  is a tuple object and `N` is a constant integral expression
+specifying the index of the element to be accessed. Depending on whether `t`
+is const or not, `get` returns the `N`-th element as a reference to const or
+non-const type. The index of the first element is `0` and thus `N` must be
+between `0` and /k/`-1`, where /k/ is the number of elements in the tuple.
+Violations of these constraints are detected at compile time. Examples:
+
+    double d = 2.7; A a;
+    tuple<int, double&, const A&> t(1, d, a);
+    const tuple<int, double&, const A&> ct = t;
+      ...
+    int i = get<0>(t); i = t.get<0>();        // ok
+    int j = get<0>(ct);                       // ok
+    get<0>(t) = 5;                            // ok
+    get<0>(ct) = 5;                           // error, can't assign to const
+      ...
+    double e = get<1>(t); // ok
+    get<1>(t) = 3.14;     // ok
+    get<2>(t) = A();      // error, can't assign to const
+    A aa = get<3>(t);     // error: index out of bounds
+      ...
+    ++get<0>(t);  // ok, can be used as any variable
+
+/[Note:/ The member `get` functions are not supported with MS Visual C++
+compiler. Further, the compiler has trouble with finding the non-member `get`
+functions without an explicit namespace qualifier. Hence, all `get` calls
+should be qualified as `tuples::get<N>(a_tuple)` when writing code that should
+compile with MSVC++ 6.0./]/
+
+[endsect]
+
+[section:construction_and_assignment Copy Construction and Tuple Assignment]
+
+A tuple can be copy constructed from another tuple, provided that the element
+types are element-wise copy constructible. Analogously, a tuple can be
+assigned to another tuple, provided that the element types are element-wise
+assignable. For example:
+
+    class A {};
+    class B : public A {};
+    struct C { C(); C(const B&); };
+    struct D { operator C() const; };
+    tuple<char, B*, B, D> t;
+      ...
+    tuple<int, A*, C, C> a(t); // ok
+    a = t;                     // ok
+
+In both cases, the conversions performed are:
+
+* `char -> int`,
+* `B* -> A*` (derived class pointer to base class pointer),
+* `B -> C` (a user defined conversion), and
+* `D -> C` (a user defined conversion).
+
+Note that assignment is also defined from `std::pair` types:
+
+    tuple<float, int> a = std::make_pair(1, 'a');
+
+[endsect]
+
+[section:relational_operators Relational Operators]
+
+Tuples reduce the operators `==`, `!=`, `<`, `>`, `<=` and `>=` to the
+corresponding elementary operators. This means, that if any of these operators
+is defined between all elements of two tuples, then the same operator is
+defined between the tuples as well. The equality operators for two tuples `a`
+and `b` are defined as:
+
+* `a == b` iff for each `i`: `a`'''<subscript>i</subscript>'''` == b`'''<subscript>i</subscript>'''
+* `a != b` iff exists `i`: `a`'''<subscript>i</subscript>'''` != b`'''<subscript>i</subscript>'''
+
+The operators `<`, `>`, `<=` and `>=` implement a lexicographical ordering.
+
+Note that an attempt to compare two tuples of different lengths results in a
+compile time error. Also, the comparison operators are /"short-circuited"/:
+elementary comparisons start from the first elements and are performed only
+until the result is clear.
+
+Examples:
+
+    tuple<std::string, int, A> t1(std::string("same?"), 2, A());
+    tuple<std::string, long, A> t2(std::string("same?"), 2, A());
+    tuple<std::string, long, A> t3(std::string("different"), 3, A());
+
+    bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
+
+    t1 == t2;               // true
+    t1 == t3;               // false, does not print "All the..."
+
+[endsect]
+
+[section:tiers Tiers]
+
+/Tiers/ are tuples, where all elements are of non-const reference types. They
+are constructed with a call to the `tie` function template (cf. `make_tuple`):
+
+    int i; char c; double d;
+      ...
+    tie(i, c, a);
+
+The above `tie` function creates a tuple of type `tuple<int&, char&, double&>`.
+The same result could be achieved with the call `make_tuple(ref(i), ref(c), ref(a))`.
+
+A tuple that contains non-const references as elements can be used to 'unpack'
+another tuple into variables. E.g.:
+
+    int i; char c; double d;
+    tie(i, c, d) = make_tuple(1,'a', 5.5);
+    std::cout << i << " " <<  c << " " << d;
+
+This code prints `1 a 5.5` to the standard output stream. A tuple unpacking
+operation like this is found for example in ML and Python. It is convenient
+when calling functions which return tuples.
+
+The tying mechanism works with `std::pair` templates as well:
+
+    int i; char c;
+    tie(i, c) = std::make_pair(1, 'a');
+
+[section Ignore]
+
+There is also an object called `ignore` which allows you to ignore an element
+assigned by a tuple. The idea is that a function may return a tuple, only part
+of which you are interested in. For example (note, that ignore is under the
+`tuples` subnamespace):
+
+    char c;
+    tie(tuples::ignore, c) = std::make_pair(1, 'a');
+
+[endsect]
+
+[endsect]
+
+[section:streaming Streaming]
+
+The global `operator<<` has been overloaded for `std::ostream` such that
+tuples are output by recursively calling `operator<<` for each element.
+
+Analogously, the global `operator>>` has been overloaded to extract tuples
+from `std::istream` by recursively calling `operator>>` for each element.
+
+The default delimiter between the elements is space, and the tuple is enclosed
+in parenthesis. For Example:
+
+    tuple<float, int, std::string> a(1.0f,  2, std::string("Howdy folks!");
+
+    cout << a;
+
+outputs the tuple as: `(1.0 2 Howdy folks!)`
+
+The library defines three manipulators for changing the default behavior:
+
+* `set_open(char)` defines the character that is output before the first element.
+* `set_close(char)` defines the character that is output after the last element.
+* `set_delimiter(char)` defines the delimiter character between elements.
+
+Note, that these manipulators are defined in the tuples subnamespace. For
+example:
+
+    cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
+
+outputs the same tuple `a` as: `[1.0,2,Howdy folks!]`
+
+The same manipulators work with `operator>>` and `istream` as well. Suppose
+the `cin` stream contains the following data:
+
+    (1 2 3) [4:5]
+
+The code:
+
+    tuple<int, int, int> i;
+    tuple<int, int> j;
+
+    cin >> i;
+    cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');
+    cin >> j;
+
+reads the data into the tuples `i` and `j`.
+
+Note that extracting tuples with `std::string` or C-style string elements does
+not generally work, since the streamed tuple representation may not be
+unambiguously parseable.
+
+[endsect]
+
+[section:performance Performance]
+
+All tuple access and construction functions are small inlined one-liners.
+Therefore, a decent compiler can eliminate any extra cost of using tuples
+compared to using hand-written tuple like classes. Particularly, with a decent
+compiler there is no performance difference between this code:
+
+    class hand_made_tuple {
+      A a; B b; C c;
+    public:
+      hand_made_tuple(const A& aa, const B& bb, const C& cc)
+        : a(aa), b(bb), c(cc) {};
+      A& getA() { return a; };
+      B& getB() { return b; };
+      C& getC() { return c; };
+    };
+
+    hand_made_tuple hmt(A(), B(), C());
+    hmt.getA(); hmt.getB(); hmt.getC();
+
+and this code:
+
+    tuple<A, B, C> t(A(), B(), C());
+    t.get<0>(); t.get<1>(); t.get<2>();
+
+Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to
+optimize this kind of tuple usage.
+
+Depending on the optimizing ability of the compiler, the tier mechanism may
+have a small performance penalty compared to using non-const reference
+parameters as a mechanism for returning multiple values from a function. For
+example, suppose that the following functions `f1` and `f2` have equivalent
+functionalities:
+
+    void f1(int&, double&);
+    tuple<int, double> f2();
+
+Then, the call #1 may be slightly faster than #2 in the code below:
+
+    int i; double d;
+      ...
+    f1(i,d);         // #1
+    tie(i,d) = f2(); // #2
+
+See [[link publ_1 1], [link publ_2 2]] for more in-depth discussions about 
+efficiency.
+
+[section Effect on Compile Time]
+
+Compiling tuples can be slow due to the excessive amount of template
+instantiations. Depending on the compiler and the tuple length, it may be more
+than 10 times slower to compile a tuple construct, compared to compiling an
+equivalent explicitly written class, such as the `hand_made_tuple` class above.
+However, as a realistic program is likely to contain a lot of code in addition
+to tuple definitions, the difference is probably unnoticeable. Compile time
+increases between 5 and 10 percent were measured for programs which used tuples
+very frequently. With the same test programs, memory consumption of compiling
+increased between 22% to 27%. See [[link publ_1 1], [link publ_2 2]] for
+details.
+
+[endsect]
+
+[endsect]
+
+[section:portability Portability]
+
+The library code is(?) standard C++ and thus the library works with a standard
+conforming compiler. Below is a list of compilers and known problems with each
+compiler:
+
+[table
+    [[Compiler]        [Problems]]
+    [[gcc 2.95]        [-]]
+    [[edg 2.44]        [-]]
+    [[Borland 5.5]     [Can't use function pointers or member pointers as
+                       tuple elements]]
+    [[Metrowerks 6.2]  [Can't use `ref` and `cref` wrappers]]
+    [[MS Visual C++]   [No reference elements (`tie` still works). Can't use
+                       `ref` and `cref` wrappers]]
+]
+
+[endsect]
+
+[section:more_details More Details]
+
+[link tuple_advanced_interface Advanced features] (describes some metafunctions etc.).
+
+[link design_decisions_rationale Rationale behind some design/implementation decisions].
+
+[endsect]
+
+[section:thanks Acknowledgements]
+
+Gary Powell has been an indispensable helping hand. In particular, stream
+manipulators for tuples were his idea. Doug Gregor came up with a working
+version for MSVC, David Abrahams found a way to get rid of most of the
+restrictions for compilers not supporting partial specialization. Thanks to
+Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. The
+comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David
+Abrahams and Hartmut Kaiser helped to improve the library. The idea for the
+`tie` mechanism came from an old usenet article by Ian McCulloch, where he
+proposed something similar for `std::pair`s.
+
+[endsect]
+
+[section:references References]
+
+[#publ_1]
+[1] J\u00E4rvi J.: /Tuples and multiple return values in C++/, TUCS Technical Report No 249, 1999.
+
+[#publ_2]
+[2] J\u00E4rvi J.: /ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism/, TUCS Technical Report No 267, 1999.
+
+[#publ_3]
+[3] J\u00E4rvi J.: /Tuple Types and Multiple Return Values/, C/C++ Users Journal, August 2001.
+
+[endsect]
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/tuple_basic.hpp
--- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
@ -1,756 +0,0 @@
-// - tuple_basic_no_partial_spec.hpp -----------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
-// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
-//
-// Permission to copy, use, sell and distribute 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.
-
-// For more information, see http://www.boost.org or http://lambda.cs.utu.fi 
-
-// Revision History 
-//  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
-//  10 02 01    Fixed "null_type" constructors.
-//              Implemented comparison operators globally.
-//              Hide element_type_ref and element_type_const_ref.
-//              (DG).
-//  09 02 01    Extended to tuples of length 10. Changed comparison for 
-//              operator<()
-//              to the same used by std::pair<>, added cnull_type() (GP)
-//  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-
-#include "boost/type_traits.hpp"
-#include <utility>
-
-#if defined BOOST_MSVC
-#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
-#pragma warning(disable:4181) // qualifier applied to reference type ignored
-#pragma warning(disable:4227) // qualifier applied to reference type ignored
-#endif
-
-namespace boost {
-namespace tuples {
-
-    // null_type denotes the end of a list built with "cons"
-    struct null_type 
-    {
-      null_type() {}
-      null_type(const null_type&, const null_type&) {}
-    };
-     
-    // a helper function to provide a const null_type type temporary
-    inline const null_type cnull_type() { return null_type(); }
-
-// forward declaration of tuple
-    template<
-      typename T1 = null_type, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
-      typename T4 = null_type,
-      typename T5 = null_type,
-      typename T6 = null_type,
-      typename T7 = null_type,
-      typename T8 = null_type,
-      typename T9 = null_type,
-      typename T10 = null_type
-    >
-    class tuple;
-
-    namespace detail {
-
-      // Takes a pointer and routes all assignments to whatever it points to
-      template<typename T>
-      struct assign_to_pointee
-      {
-      public:
-        explicit assign_to_pointee(T* p) : ptr(p) {}
-
-        template<typename Other>
-        assign_to_pointee& operator=(const Other& other)
-        {
-          *ptr = other;
-          return *this;
-        }
-
-      private:
-        T* ptr;
-      };
-
-      // Swallows any assignment
-      struct swallow_assign
-      {
-        template<typename T>
-        swallow_assign& operator=(const T&)
-        {
-          return *this;
-        }
-      };
-
-  } // end of namespace detail
-
-    // cons builds a heterogenous list of types
-   template<typename Head, typename Tail = null_type>
-   struct cons
-   {
-     typedef cons self_type;
-     typedef Head head_type;
-     typedef Tail tail_type;
-
-     head_type head;
-     tail_type tail;
-
-     typename boost::add_reference<head_type>::type get_head() { return head; }
-     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
-
-     typename boost::add_reference<const head_type>::type get_head() const { return head; }
-     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
-  
-#if defined BOOST_MSVC
-      template<typename Tail>
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
-                    const Tail& t) : head(h), tail(t.head, t.tail)
-      {
-      }
-
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
-                    const null_type& t) : head(h), tail(t)
-      {
-      }
-
-#else
-      template<typename T>
-      explicit cons(const head_type& h, const T& t) : 
-        head(h), tail(t.head, t.tail)
-      {
-      }
-
-      explicit cons(const head_type& h = head_type(),
-                    const tail_type& t = tail_type()) :
-        head(h), tail(t)
-      {
-      }
-#endif
-
-
-      template<typename Other>
-      cons& operator=(const Other& other)
-      {
-        head = other.head;
-        tail = other.tail;
-        return *this;
-      }
-    };
-  
-    namespace detail {
-
-      // Determines if the parameter is null_type
-      template<typename T> struct is_null_type { enum { RET = 0 }; };
-      template<> struct is_null_type<null_type> { enum { RET = 1 }; };
-      
-      /* Build a cons structure from the given Head and Tail. If both are null_type,
-      return null_type. */
-      template<typename Head, typename Tail>
-      struct build_cons
-      {
-      private:
-        enum { tail_is_null_type = is_null_type<Tail>::RET };
-      public:
-        typedef cons<Head, Tail> RET;
-      };
-
-      template<>
-      struct build_cons<null_type, null_type>
-      {
-        typedef null_type RET;
-      };
-
-      // Map the N elements of a tuple into a cons list
-      template<
-        typename T1, 
-        typename T2 = null_type, 
-        typename T3 = null_type, 
-        typename T4 = null_type, 
-        typename T5 = null_type, 
-        typename T6 = null_type, 
-        typename T7 = null_type, 
-        typename T8 = null_type, 
-        typename T9 = null_type, 
-        typename T10 = null_type
-      >
-      struct map_tuple_to_cons
-      {
-        typedef typename detail::build_cons<T10, null_type  >::RET cons10;
-        typedef typename detail::build_cons<T9, cons10>::RET cons9;
-        typedef typename detail::build_cons<T8, cons9>::RET cons8;
-        typedef typename detail::build_cons<T7, cons8>::RET cons7;
-        typedef typename detail::build_cons<T6, cons7>::RET cons6;
-        typedef typename detail::build_cons<T5, cons6>::RET cons5;
-        typedef typename detail::build_cons<T4, cons5>::RET cons4;
-        typedef typename detail::build_cons<T3, cons4>::RET cons3;
-        typedef typename detail::build_cons<T2, cons3>::RET cons2;
-        typedef typename detail::build_cons<T1, cons2>::RET cons1;
-      };
-
-      // Workaround the lack of partial specialization in some compilers
-      template<int N>
-      struct _element_type
-      {
-        template<typename Tuple>
-        struct inner
-        {
-        private:
-          typedef typename Tuple::tail_type tail_type;
-          typedef _element_type<N-1> next_elt_type;
-
-        public:
-          typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
-        };
-      };
-
-      template<>
-      struct _element_type<0>
-      {
-        template<typename Tuple>
-        struct inner
-        {
-          typedef typename Tuple::head_type RET;
-        };
-      };
-
-    } // namespace detail
-
-
-    // Return the Nth type of the given Tuple
-    template<int N, typename Tuple>
-    struct element
-    {
-    private:
-      typedef detail::_element_type<N> nth_type;
-
-    public:
-      typedef typename nth_type::template inner<Tuple>::RET RET;
-      typedef RET type;
-    };
-
-    namespace detail {
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-      // special workaround for vc7:
-
-      template <bool x>
-      struct reference_adder
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T& type;
-         };
-      };
-
-      template <>
-      struct reference_adder<true>
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T type;
-         };
-      };
-
-
-      // Return a reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
-         typedef RET type;
-      };
-
-      // Return a const reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_const_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
-         typedef RET type;
-      };
-
-#else // vc7
-
-      // Return a reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_ref
-      {
-      private:
-        typedef typename element<N, Tuple>::RET elt_type;
-
-      public:
-        typedef typename add_reference<elt_type>::type RET;
-        typedef RET type;
-      };
-
-      // Return a const reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_const_ref
-      {
-      private:
-        typedef typename element<N, Tuple>::RET elt_type;
-
-      public:
-        typedef typename add_reference<const elt_type>::type RET;
-        typedef RET type;
-      };
-#endif // vc7
-
-    } // namespace detail
-
-    // Get length of this tuple
-    template<typename Tuple>
-    struct length
-    {
-      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
-    };
-    
-    template<> struct length<tuple<> > {
-      BOOST_STATIC_CONSTANT(int, value = 0);
-    };
-
-    template<>
-    struct length<null_type>
-    {
-      BOOST_STATIC_CONSTANT(int, value = 0);
-    };
-
-    namespace detail {
-
-    // Reference the Nth element in a tuple and retrieve it with "get"
-    template<int N>
-    struct get_class
-    {
-      template<typename Head, typename Tail>
-      static inline
-      typename detail::element_ref<N, cons<Head, Tail> >::RET
-      get(cons<Head, Tail>& t)
-      {
-        return get_class<N-1>::get(t.tail);
-      }
-
-      template<typename Head, typename Tail>
-      static inline
-      typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-      get(const cons<Head, Tail>& t)
-      {
-        return get_class<N-1>::get(t.tail);
-      }
-    };
-
-    template<>
-    struct get_class<0>
-    {
-      template<typename Head, typename Tail>
-      static inline
-      typename add_reference<Head>::type
-      get(cons<Head, Tail>& t)
-      {
-        return t.head;
-      }
-
-      template<typename Head, typename Tail>
-      static inline
-      typename add_reference<const Head>::type
-      get(const cons<Head, Tail>& t)
-      {
-        return t.head;
-      }
-    };
-
-    } // namespace detail
-
-    // tuple class
-    template<
-      typename T1, 
-      typename T2, 
-      typename T3, 
-      typename T4,
-      typename T5,
-      typename T6,
-      typename T7,
-      typename T8,
-      typename T9,
-      typename T10
-    >
-    class tuple : 
-      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
-    {
-    private:
-      typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
-      typedef typename mapped_tuple::cons10 cons10;
-      typedef typename mapped_tuple::cons9 cons9;
-      typedef typename mapped_tuple::cons8 cons8;
-      typedef typename mapped_tuple::cons7 cons7;
-      typedef typename mapped_tuple::cons6 cons6;
-      typedef typename mapped_tuple::cons5 cons5;
-      typedef typename mapped_tuple::cons4 cons4;
-      typedef typename mapped_tuple::cons3 cons3;
-      typedef typename mapped_tuple::cons2 cons2;
-      typedef typename mapped_tuple::cons1 cons1;
-
-    public:
-      typedef cons1 inherited;
-      typedef tuple self_type;
-
-      explicit tuple(const T1& t1 = T1(), 
-                     const T2& t2 = T2(),
-                     const T3& t3 = T3(),
-                     const T4& t4 = T4(),
-                     const T5& t5 = T5(),
-                     const T6& t6 = T6(),
-                     const T7& t7 = T7(),
-                     const T8& t8 = T8(),
-                     const T9& t9 = T9(),
-                     const T10& t10 = T10()) :
-        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
-      {
-      }
-
-      template<typename Head, typename Tail>
-      explicit tuple(const cons<Head, Tail>& other) : 
-        cons1(other.head, other.tail)
-      {
-      }
-
-      template<typename First, typename Second>
-      self_type& operator=(const std::pair<First, Second>& other)
-      {
-        this->head = other.first;
-        this->tail.head = other.second;
-        return *this;
-      }
-
-      template<typename Head, typename Tail>
-      self_type& operator=(const cons<Head, Tail>& other)
-      {
-        this->head = other.head;
-        this->tail = other.tail;
-
-        return *this;
-      }
-    };
-
-    namespace detail {
-
-      template<int N> struct workaround_holder {};
-
-    } // namespace detail
-
-    template<int N, typename Head, typename Tail>
-    typename detail::element_ref<N, cons<Head, Tail> >::RET
-    get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
-    {
-      return detail::get_class<N>::get(t);
-    }
-
-    template<int N, typename Head, typename Tail>
-    typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-    get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
-    {
-      return detail::get_class<N>::get(t);
-    }
-
-    // Make a tuple
-    template<typename T1>
-    inline
-    tuple<T1>
-    make_tuple(const T1& t1)
-    {
-      return tuple<T1>(t1);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2>
-    inline
-    tuple<T1, T2>
-    make_tuple(const T1& t1, const T2& t2)
-    {
-      return tuple<T1, T2>(t1, t2);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3>
-    inline
-    tuple<T1, T2, T3>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3)
-    {
-      return tuple<T1, T2, T3>(t1, t2, t3);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4>
-    inline
-    tuple<T1, T2, T3, T4>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
-    {
-      return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    inline
-    tuple<T1, T2, T3, T4, T5>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
-    {
-      return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
-    }
-  
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-    }
-
-    // Tie variables into a tuple
-    template<typename T1>
-    inline
-    tuple<detail::assign_to_pointee<T1> >
-    tie(T1& t1)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2> >
-    tie(T1& t1, T2& t2)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3> >
-    tie(T1& t1, T2& t2, T3& t3)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
-      detail::assign_to_pointee<T9> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8),
-                        detail::assign_to_pointee<T9>(&t9));
-    }
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
-      detail::assign_to_pointee<T9>, 
-      detail::assign_to_pointee<T10> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8),
-                        detail::assign_to_pointee<T9>(&t9),
-                        detail::assign_to_pointee<T10>(&t10));
-    }
-    // "ignore" allows tuple positions to be ignored when using "tie". 
-    namespace {
-      detail::swallow_assign ignore;
-    }
-
-} // namespace tuples
-} // namespace boost
-#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -1,45 +1,41 @@
 //  tuple.hpp - Boost Tuple Library --------------------------------------

-// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute 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.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)

 // For more information, see http://www.boost.org

-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------

 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP

-#include "boost/config.hpp"
-#include "boost/static_assert.hpp"
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif

-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// The MSVC version
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>

-#else
 // other compilers
-#include "boost/ref.hpp"
-#include "boost/tuple/detail/tuple_basic.hpp"
+#include <boost/ref.hpp>
+#include <boost/tuple/detail/tuple_basic.hpp>

-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

-namespace boost {    
+namespace boost {

 using tuples::tuple;
 using tuples::make_tuple;
 using tuples::tie;
 #if !defined(BOOST_NO_USING_TEMPLATE)
 using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
 //
 // The "using tuples::get" statement causes the
 // Borland compiler to ICE, use forwarding
@ -51,7 +47,7 @@ inline typename tuples::access_traits<
                >::non_const_type
 get(tuples::cons<HT, TT>& c) {
  return tuples::get<N,HT,TT>(c);
-} 
+}
 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
 // as such (that is, can return a non-const reference)
@ -62,26 +58,9 @@ inline typename tuples::access_traits<
 get(const tuples::cons<HT, TT>& c) {
  return tuples::get<N,HT,TT>(c);
 }
-#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}

-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
 #endif // BOOST_NO_USING_TEMPLATE
-   
+
 } // end namespace boost


--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -1,36 +1,31 @@
 // tuple_comparison.hpp -----------------------------------------------------
-//  
-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+//
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute 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.
-// 
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
 // For more information, see http://www.boost.org
-// 
+//
 // (The idea and first impl. of comparison operators was from Doug Gregor)

-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------

 #ifndef BOOST_TUPLE_COMPARISON_HPP
 #define BOOST_TUPLE_COMPARISON_HPP

-#include "boost/tuple/tuple.hpp"
+#include <boost/tuple/tuple.hpp>

 // -------------------------------------------------------------
-// equality and comparison operators 
+// equality and comparison operators
 //
 // == and != compare tuples elementwise
 // <, >, <= and >= use lexicographical ordering
 //
 // Any operator between tuples of different length fails at compile time
-// No dependencies between operators are assumed 
+// No dependencies between operators are assumed
 // (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
 // so any weirdnesses of elementary operators are respected).
 //
@ -51,7 +46,7 @@ inline bool operator>(const null_type&, const null_type&) { return false; }
 namespace detail {
  // comparison operators check statically the length of its operands and
  // delegate the comparing task to the following functions. Hence
-  // the static check is only made once (should help the compiler).  
+  // the static check is only made once (should help the compiler).
  // These functions assume tuples to be of the same length.


@ -74,8 +69,8 @@ inline bool neq<null_type,null_type>(const null_type&, const null_type&) { retur
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
  return lhs.get_head() < rhs.get_head()  ||
-            !(rhs.get_head() < lhs.get_head()) &&
-            lt(lhs.get_tail(), rhs.get_tail());
+          ( !(rhs.get_head() < lhs.get_head()) &&
+            lt(lhs.get_tail(), rhs.get_tail()));
 }
 template<>
 inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
@ -83,8 +78,8 @@ inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return
 template<class T1, class T2>
 inline bool gt(const T1& lhs, const T2& rhs) {
  return lhs.get_head() > rhs.get_head()  ||
-            !(rhs.get_head() > lhs.get_head()) &&
-            gt(lhs.get_tail(), rhs.get_tail());
+          ( !(rhs.get_head() > lhs.get_head()) &&
+            gt(lhs.get_tail(), rhs.get_tail()));
 }
 template<>
 inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -1,40 +1,41 @@
 // tuple_io.hpp --------------------------------------------------------------

-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute 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.
-// For more information, see http://www.boost.org 
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// For more information, see http://www.boost.org

 // ----------------------------------------------------------------------------

 #ifndef BOOST_TUPLE_IO_HPP
 #define BOOST_TUPLE_IO_HPP

-
-// add to boost/config.hpp
-// for now
-# if defined __GNUC__
-#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
-#define BOOST_NO_TEMPLATED_STREAMS
-#endif
-#endif // __GNUC__
-
-#if defined BOOST_NO_TEMPLATED_STREAMS
-#include <iostream>
-#else 
 #include <istream>
 #include <ostream>
-#endif  

-#include "boost/tuple/tuple.hpp"
+#include <sstream>
+
+#include <boost/tuple/tuple.hpp>
+
+// This is ugly: one should be using twoargument isspace since whitspace can
+// be locale dependent, in theory at least.
+// not all libraries implement have the two-arg version, so we need to
+// use the one-arg one, which one should get with <cctype> but there seem
+// to be exceptions to this.
+
+#if !defined (BOOST_NO_STD_LOCALE)
+
+#include <locale> // for two-arg isspace
+
+#else
+
+#include <cctype> // for one-arg (old) isspace
+#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
+
+#endif

 namespace boost {
 namespace tuples {
@ -42,12 +43,12 @@ namespace tuples {
 namespace detail {

 class format_info {
-public:   
+public:

   enum manipulator_type { open, close, delimiter };
   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
-   
+
   static int get_stream_index (int m)
   {
     static const int stream_index[number_of_manipulators]
@ -57,44 +58,25 @@ private:
   }

   format_info(const format_info&);
-   format_info();   
+   format_info();


 public:

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-   static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(get_stream_index(m))); 
-     
-     // parentheses and space are the default manipulators
-     if (!c) {
-       switch(m) {
-         case open : c = '('; break;
-         case close : c = ')'; break;
-         case delimiter : c = ' '; break;
-       }
-     }
-     return c;
-   }
-
-   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
-   }
-#else
   template<class CharType, class CharTrait>
-   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i,
                                   manipulator_type m) {
     // The manipulators are stored as long.
     // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if long is not convertible 
+     // hence, the static_cast may fail (it fails if long is not convertible
     // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) );
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open :  c = i.widen('('); break;
-         case close : c = i.widen(')'); break;
-         case delimiter : c = i.widen(' '); break;
+         case detail::format_info::open :  c = i.widen('('); break;
+         case detail::format_info::close : c = i.widen(')'); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -102,61 +84,33 @@ public:


   template<class CharType, class CharTrait>
-   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i,
                               manipulator_type m, CharType c) {
     // The manipulators are stored as long.
     // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if CharType is not 
+     // hence, the static_cast may fail (it fails if CharType is not
     // convertible long.
      i.iword(get_stream_index(m)) = static_cast<long>(c);
   }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };

 } // end of namespace detail
- 
-template<class CharType>    
+
+template<class CharType>
 class tuple_manipulator {
  const detail::format_info::manipulator_type mt;
  CharType f_c;
 public:
-  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
+  explicit tuple_manipulator(detail::format_info::manipulator_type m,
                             const char c = 0)
     : mt(m), f_c(c) {}
-  
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-  void set(std::ios &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   template<class CharType2, class CharTrait>
-  void set(std::basic_ios<CharType2, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
+
   template<class CharTrait>
  void set(std::basic_ios<CharType, CharTrait> &io) const {
     detail::format_info::set_manipulator(io, mt, f_c);
  }
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-inline std::ostream&
-operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
-  m.set(o);
-  return o;
-}
-
-inline std::istream&
-operator>>(std::istream& i, const tuple_manipulator<char>& m) {
-  m.set(i);
-  return i;
-}
-
-#else

 template<class CharType, class CharTrait>
 inline std::basic_ostream<CharType, CharTrait>&
@ -172,8 +126,7 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
  return i;
 }

-#endif   // BOOST_NO_TEMPLATED_STREAMS
-   
+
 template<class CharType>
 inline tuple_manipulator<CharType> set_open(const CharType c) {
   return tuple_manipulator<CharType>(detail::format_info::open, c);
@ -191,271 +144,158 @@ inline tuple_manipulator<CharType> set_delimiter(const CharType c) {



-   
-   
+
+
 // -------------------------------------------------------------
 // printing tuples to ostream in format (a b c)
 // parentheses and space are defaults, but can be overriden with manipulators
 // set_open, set_close and set_delimiter
-   
+
 namespace detail {

-// Note: The order of the print functions is critical 
+// Note: The order of the print functions is critical
 // to let a conforming compiler  find and select the correct one.

-#if defined (BOOST_NO_TEMPLATED_STREAMS)

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
-  return o << t.head;
-}
-#endif // BOOST_NO_TEMPLATED_STREAMS
- 
-inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
-
-template<class T1, class T2>
-inline std::ostream& 
-print(std::ostream& o, const cons<T1, T2>& t) {
-  
-  const char d = format_info::get_manipulator(o, format_info::delimiter);
-   
-  o << t.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  o << d;
-  
-  return print(o, t.tail );
-
-}
-
-
-
-#else
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 template<class CharType, class CharTrait, class T1>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
 print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
  return o << t.head;
 }
-#endif  // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

- 
+
 template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
-  return o; 
+inline std::basic_ostream<CharType, CharTrait>&
+print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
+  return o;
 }

 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
 print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
-  
+
  const CharType d = format_info::get_manipulator(o, format_info::delimiter);
-   
+
  o << t.head;

-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  o << d;

  return print(o, t.tail);
 }

-#endif  // BOOST_NO_TEMPLATED_STREAMS
+template<class CharT, class Traits, class T>
+inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
+    std::streamsize width = o.width();
+    if(width == 0) return false;
+
+    std::basic_ostringstream<CharT, Traits> ss;
+
+    ss.copyfmt(o);
+    ss.tie(0);
+    ss.width(0);
+
+    ss << t;
+    o << ss.str();
+
+    return true;
+}
+

 } // namespace detail

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-template<class T1, class T2>
-inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
-  if (!o.good() ) return o;
- 
-  const char l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const char r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;
-  
-  detail::print(o, t);  

+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& o,
+           const null_type& t) {
+  if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
+
+  const CharType l =
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r =
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+
+  o << l;
  o << r;

  return o;
 }

-#else
-
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+inline std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& o,
           const cons<T1, T2>& t) {
  if (!o.good() ) return o;
- 
-  const CharType l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const CharType r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;   
+  if (detail::handle_width(o, t)) return o;

-  detail::print(o, t);  
+  const CharType l =
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r =
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+
+  o << l;
+
+  detail::print(o, t);

  o << r;

  return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS

-   
+
 // -------------------------------------------------------------
 // input stream operators

 namespace detail {

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-
-inline std::istream& 
-extract_and_check_delimiter(
-  std::istream& is, format_info::manipulator_type del)
-{
-  const char d = format_info::get_manipulator(is, del);
-
-  const bool is_delimiter = (!isspace(d) );      
-
-  char c;
-  if (is_delimiter) { 
-    is >> c; 
-    if (c!=d) {
-      is.setstate(std::ios::failbit);
-    } 
-  }
-  return is;
-}
-
-
-// Note: The order of the read functions is critical to let a 
-// (conforming?) compiler find and select the correct one.
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline  std::istream & 
-read (std::istream &is, cons<T1, null_type>& t1) {
-
-  if (!is.good()) return is;   
-   
-  return is >> t1.head ;
-}
-#else
-inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   
-template<class T1, class T2>
-inline std::istream& 
-read(std::istream &is, cons<T1, T2>& t1) {
-
-  if (!is.good()) return is;
-   
-  is >> t1.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-  extract_and_check_delimiter(is, format_info::delimiter);
-
-  return read(is, t1.tail);
-}
-
-} // end namespace detail
-
-inline std::istream& 
-operator>>(std::istream &is, null_type&) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-template<class T1, class T2>
-inline std::istream& 
-operator>>(std::istream& is, cons<T1, T2>& t1) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
-  detail::read(is, t1);
-   
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-
-#else

 template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 extract_and_check_delimiter(
  std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
 {
  const CharType d = format_info::get_manipulator(is, del);

-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( __BORLANDC__ )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );
+#endif

  CharType c;
-  if (is_delimiter) { 
+  if (is_delimiter) {
    is >> c;
-    if (c!=d) { 
+    if (is.good() && c!=d) {
      is.setstate(std::ios::failbit);
    }
+  } else {
+    is >> std::ws;
  }
  return is;
 }

-   
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
 template<class CharType, class CharTrait, class T1>
-inline  std::basic_istream<CharType, CharTrait> & 
+inline  std::basic_istream<CharType, CharTrait> &
 read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {

-  if (!is.good()) return is;   
-   
-  return is >> t1.head; 
-}
-#else
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
+  if (!is.good()) return is;

-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  return is >> t1.head;
+}

 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {

  if (!is.good()) return is;
-   
+
  is >> t1.head;

-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

  extract_and_check_delimiter(is, format_info::delimiter);

@ -466,7 +306,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {


 template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {

  if (!is.good() ) return is;
@ -478,25 +318,22 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
 }

 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {

  if (!is.good() ) return is;

  detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
+
  detail::read(is, t1);
-   
+
  detail::extract_and_check_delimiter(is, detail::format_info::close);

  return is;
 }

-#endif // BOOST_NO_TEMPLATED_STREAMS

 } // end of namespace tuples
 } // end of namespace boost

 #endif // BOOST_TUPLE_IO_HPP
-
-
--- a/index.html
+++ b/index.html
@ -0,0 +1,13 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/html/tuple_users_guide.html">
+</head>
+<body>
+Automatic redirection failed, please go to <a href="doc/html/tuple_users_guide.html">doc/html/tuple_users_guide.html</a> 
+&nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -0,0 +1,17 @@
+{
+    "key": "tuple",
+    "name": "Tuple",
+    "authors": [
+        "Jaakko Järvi"
+    ],
+    "description": "Ease definition of functions returning multiple values, and more.",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Data"
+    ],
+    "maintainers": [
+        "Jaakko Jarvi <jarvi -at- cs.tamu.edu>"
+    ]
+}
--- a/test/Jamfile
+++ b/test/Jamfile
@ -0,0 +1,8 @@
+
+project : requirements <library>/boost/test//boost_test_exec_monitor ;
+
+test-suite tuple : 
+    [ run tuple_test_bench.cpp ]
+    [ run io_test.cpp ]
+    [ run another_tuple_test_bench.cpp ]
+    ;
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -1,3 +1,12 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+
 //  another_test_bench.cpp  --------------------------------

 // This file has various tests to see that things that shouldn't
@ -14,7 +23,6 @@
 #include <string>
 #include <utility>

-using namespace std;
 using namespace boost;
 using namespace boost::tuples;

@ -89,12 +97,11 @@ void foo2() {

 void foo4() 
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double d = 2.7; 
  A a;
  tuple<int, double&, const A&> t(1, d, a);
  const tuple<int, double&, const A> ct = t;
-
+  (void)ct;
 #ifdef E8
  get<0>(ct) = 5; // can't assign to const
 #endif
@ -105,8 +112,6 @@ void foo4()
 #ifdef E10
  dummy(get<5>(ct)); // illegal index
 #endif
-
-#endif
 }

 // testing copy and assignment with implicit conversions between elements
@ -119,9 +124,10 @@ void foo4()

  void foo5() {
    tuple<char, BB*, BB, DD> t;
-
+    (void)t;
    tuple<char, char> aaa;
    tuple<int, int> bbb(aaa);
+    (void)bbb;
    //    tuple<int, AA*, CC, CC> a = t;
    //    a = t;
  }
--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -1,3 +1,11 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
 // -- io_test.cpp -----------------------------------------------
 //
 // Testing the I/O facilities of tuples
@ -12,6 +20,7 @@
 #include <iterator>
 #include <algorithm>
 #include <string>
+#include <iomanip>

 #if defined BOOST_NO_STRINGSTREAM
 #include <strstream>
@ -19,21 +28,19 @@
 #include <sstream>
 #endif

-#include "boost/config.hpp"
-
-using namespace std;
 using namespace boost;

 #if defined BOOST_NO_STRINGSTREAM
-typedef ostrstream useThisOStringStream;
-typedef istrstream useThisIStringStream;
+typedef std::ostrstream useThisOStringStream;
+typedef std::istrstream useThisIStringStream;
 #else
-typedef ostringstream useThisOStringStream;
-typedef istringstream useThisIStringStream;
+typedef std::ostringstream useThisOStringStream;
+typedef std::istringstream useThisIStringStream;
 #endif

 int test_main(int argc, char * argv[] ) {
-
+   (void)argc;
+   (void)argv;
   using boost::tuples::set_close;
   using boost::tuples::set_open;
   using boost::tuples::set_delimiter;
@ -45,7 +52,7 @@ int test_main(int argc, char * argv[] ) {
  os1 << set_close(']');
  os1 << set_delimiter(',');
  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );

  {
  useThisOStringStream os2;
@ -55,48 +62,76 @@ int test_main(int argc, char * argv[] ) {
  os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
 #endif
  }

  // The format is still [a, b, c] for os1
  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );

-  ofstream tmp("temp.tmp");
+  // check empty tuple.
+  useThisOStringStream os3;
+  os3 << make_tuple();
+  BOOST_CHECK (os3.str() == std::string("()") );
+  os3 << set_open('[');
+  os3 << set_close(']');
+  os3 << make_tuple();
+  BOOST_CHECK (os3.str() == std::string("()[]") );
+  
+  // check width
+  useThisOStringStream os4;
+  os4 << std::setw(10) << make_tuple(1, 2, 3);
+  BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );
+
+  std::ofstream tmp("temp.tmp");

 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp << make_tuple("One", "Two", 3);
 #endif   
  tmp << set_delimiter(':');
-  tmp << make_tuple(1000, 2000, 3000) << endl;
+  tmp << make_tuple(1000, 2000, 3000) << std::endl;

  tmp.close();
  
  // When teading tuples from a stream, manipulators must be set correctly:
-  ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;
+  std::ifstream tmp3("temp.tmp");
+  tuple<std::string, std::string, int> j;

 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
 #endif
   
  tmp3 >> set_delimiter(':');
  tuple<int, int, int> i;
  tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
   
  tmp3.close(); 


  // reading tuple<int, int, int> in format (a b c); 
-  useThisIStringStream is("(100 200 300)"); 
+  useThisIStringStream is1("(100 200 300)"); 
   
-  tuple<int, int, int> ti; 
-  BOOST_TEST(is >> ti);
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
+  tuple<int, int, int> ti1; 
+  BOOST_CHECK(bool(is1 >> ti1));
+  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
+
+  useThisIStringStream is2("()");
+  tuple<> ti2;
+  BOOST_CHECK(bool(is2 >> ti2));
+  useThisIStringStream is3("[]");
+  is3 >> set_open('[');
+  is3 >> set_close(']');
+  BOOST_CHECK(bool(is3 >> ti2));
+
+  // Make sure that whitespace between elements
+  // is skipped.
+  useThisIStringStream is4("(100 200 300)"); 
   
+  BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
+  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));

  // Note that strings are problematic:
  // writing a tuple on a stream and reading it back doesn't work in
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,3 +1,11 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
 //  tuple_test_bench.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
@ -7,10 +15,12 @@

 #include "boost/tuple/tuple_comparison.hpp"

+#include "boost/type_traits/is_const.hpp"
+
+#include "boost/ref.hpp"
 #include <string>
 #include <utility>

-using namespace std;
 using namespace boost;

 // ----------------------------------------------------------------------------
@ -66,7 +76,6 @@ public:

 typedef tuple<int> t1;

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 typedef tuple<double&, const double&, const double, double*, const double*> t2;
 typedef tuple<A, int(*)(char, int), C> t3;
 typedef tuple<std::string, std::pair<A, B> > t4;
@ -77,22 +86,16 @@ typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
 typedef tuple<B(A::*)(C&), A&> t7;
 #endif

-#endif
-
 // -----------------------------------------------------------------------
 // -tuple construction tests ---------------------------------------------
 // -----------------------------------------------------------------------


-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 no_copy y;
 tuple<no_copy&> x = tuple<no_copy&>(y); // ok
-#endif

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 char cs[10];
 tuple<char(&)[10]> v2(cs);  // ok
-#endif

 void
 construction_test()
@ -103,32 +106,32 @@ construction_test()
  // MSVC 6.0 just cannot find get without the namespace qualifier

  tuple<int> t1;
-  BOOST_TEST(get<0>(t1) == int());
+  BOOST_CHECK(get<0>(t1) == int());

  tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);

  tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+  BOOST_CHECK(get<0>(t3) == foo(12));

  tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);

  tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+  BOOST_CHECK(get<0>(t5) == int());
+  BOOST_CHECK(get<1>(t5) == float());

  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+  BOOST_CHECK(get<0>(t6) == 12);
+  BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);

  tuple<int, float> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+  BOOST_CHECK(get<0>(t7) == 12);
+  BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);

  tuple<long, double> t8(t6);
-  BOOST_TEST(get<0>(t8) == 12);
-  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+  BOOST_CHECK(get<0>(t8) == 12);
+  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);

  dummy(
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@ -147,12 +150,10 @@ construction_test()
  //  dummy(tuple<double&>()); // should fail, not defaults for references
  //  dummy(tuple<const double&>()); // likewise

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double dd = 5;
  dummy(tuple<double&>(dd)); // ok

  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
-#endif

  //  dummy(tuple<double&>(dd+3.14)); // should fail,
  //                                  // temporary to non-const reference
@ -165,7 +166,6 @@ construction_test()

 void element_access_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double d = 2.7;
  A a;
  tuple<int, double&, const A&, int> t(1, d, a, 2);
@ -174,58 +174,40 @@ void element_access_test()
  int i  = get<0>(t);
  int i2 = get<3>(t);

-  BOOST_TEST(i == 1 && i2 == 2);
+  BOOST_CHECK(i == 1 && i2 == 2);

  int j  = get<0>(ct);
-  BOOST_TEST(j == 1);
+  BOOST_CHECK(j == 1);
   
  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
+  BOOST_CHECK(t.head == 5);
   
  //  get<0>(ct) = 5; // can't assign to const

  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
+  BOOST_CHECK(e > 2.69 && e < 2.71);
     
  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);

  //  get<4>(t) = A(); // can't assign to const
  //  dummy(get<5>(ct)); // illegal index

  ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
+  BOOST_CHECK(get<0>(t) == 6);
+
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
+#endif 
+
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
+#endif 
+

  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
-#else
-  double d = 2.7; 
-  A a;
-  tuple<int, double, const A, int> t(1, d, a, 2);
-
-  int i  = get<0>(t);
-  int i2 = get<3>(t);
-
-  BOOST_TEST(i == 1 && i2 == 2);
-   
-  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-  //  get<0>(ct) = 5; // can't assign to const
-
-  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-     
-  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-
-  //  get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
-
-  ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
-
-  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
-#endif
 }


@ -241,13 +223,13 @@ copy_test()
  tuple<int, char> t1(4, 'a');
  tuple<int, char> t2(5, 'b');
  t2 = t1;
-  BOOST_TEST(get<0>(t1) == get<0>(t2));
-  BOOST_TEST(get<1>(t1) == get<1>(t2));
+  BOOST_CHECK(get<0>(t1) == get<0>(t2));
+  BOOST_CHECK(get<1>(t1) == get<1>(t2));

  tuple<long, std::string> t3(2, "a");
  t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
+  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);

 // testing copy and assignment with implicit conversions between elements
 // testing tie
@ -259,9 +241,9 @@ copy_test()
  int i; char c; double d;
  tie(i, c, d) = make_tuple(1, 'a', 5.5);
  
-  BOOST_TEST(i==1);
-  BOOST_TEST(c=='a');
-  BOOST_TEST(d>5.4 && d<5.6);
+  BOOST_CHECK(i==1);
+  BOOST_CHECK(c=='a');
+  BOOST_CHECK(d>5.4 && d<5.6);
 }

 void
@ -273,10 +255,10 @@ mutate_test()
  get<2>(t1) = false;
  get<3>(t1) = foo(5);

-  BOOST_TEST(get<0>(t1) == 6);
-  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
-  BOOST_TEST(get<2>(t1) == false);
-  BOOST_TEST(get<3>(t1) == foo(5));
+  BOOST_CHECK(get<0>(t1) == 6);
+  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_CHECK(get<2>(t1) == false);
+  BOOST_CHECK(get<3>(t1) == foo(5));
 }

 // ----------------------------------------------------------------------------
@ -287,40 +269,36 @@ void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 'a');

  tuple<int, std::string> t2;
-  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
+  t2 = boost::make_tuple((short int)2, std::string("Hi"));
+  BOOST_CHECK(get<0>(t2) == 2);
+  BOOST_CHECK(get<1>(t2) == "Hi");


-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    A a; B b;
+    A a = A(); B b;
    const A ca = a;
-    make_tuple(cref(a), b);
-    make_tuple(ref(a), b);
-    make_tuple(ref(a), cref(b));
+    make_tuple(boost::cref(a), b);
+    make_tuple(boost::ref(a), b);
+    make_tuple(boost::ref(a), boost::cref(b));

-    make_tuple(ref(ca));
-#endif
+    make_tuple(boost::ref(ca));
     
 // the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
+   BOOST_CHECK(make_tuple(2, 4, 6) == 
             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    make_tuple("Donald", "Daisy"); // should work;
-#endif
+#endif 
    //    std::make_pair("Doesn't","Work"); // fails

 // You can store a reference to a function in a tuple
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    tuple<void(&)()> adf(make_tuple_test);

    dummy(adf); // avoid warning for unused variable
-#endif
 
 // But make_tuple doesn't work 
 // with function references, since it creates a const qualified function type
@ -357,19 +335,19 @@ tie_test()
  foo c(5);

  tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_TEST(a == 2);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(3));
+  BOOST_CHECK(a == 2);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(3));

  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(a == 5);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(5));
+  BOOST_CHECK(a == 5);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(5));

 // testing assignment from std::pair
   int i, j; 
   tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
+   BOOST_CHECK(i == 1 && j == 2);

   tuple<int, int, float> ta;
 #ifdef E11
@ -389,13 +367,13 @@ equality_test()
 {
  tuple<int, char> t1(5, 'a');
  tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
+  BOOST_CHECK(t1 == t2);

  tuple<int, char> t3(5, 'b');
  tuple<int, char> t4(2, 'a');
-  BOOST_TEST(t1 != t3);
-  BOOST_TEST(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
+  BOOST_CHECK(t1 != t3);
+  BOOST_CHECK(t1 != t4);
+  BOOST_CHECK(!(t1 != t2));
 }


@ -409,14 +387,14 @@ ordering_test()
  tuple<int, float> t1(4, 3.3f);
  tuple<short, float> t2(5, 3.3f);
  tuple<long, double> t3(5, 4.4);
-  BOOST_TEST(t1 < t2);
-  BOOST_TEST(t1 <= t2);
-  BOOST_TEST(t2 > t1);
-  BOOST_TEST(t2 >= t1);
-  BOOST_TEST(t2 < t3);
-  BOOST_TEST(t2 <= t3);
-  BOOST_TEST(t3 > t2);
-  BOOST_TEST(t3 >= t2);
+  BOOST_CHECK(t1 < t2);
+  BOOST_CHECK(t1 <= t2);
+  BOOST_CHECK(t2 > t1);
+  BOOST_CHECK(t2 >= t1);
+  BOOST_CHECK(t2 < t3);
+  BOOST_CHECK(t2 <= t3);
+  BOOST_CHECK(t3 > t2);
+  BOOST_CHECK(t3 >= t2);

 }

@ -426,7 +404,6 @@ ordering_test()
 // ----------------------------------------------------------------------------
 void cons_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  using tuples::cons;
  using tuples::null_type;

@ -434,11 +411,10 @@ void cons_test()
  cons<const int, cons<volatile float, null_type> > b(2,a);
  int i = 3;
  cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_TEST(make_tuple(3,2,1)==c);
+  BOOST_CHECK(make_tuple(3,2,1)==c);

  cons<char, cons<int, cons<float, null_type> > > x;
  dummy(x);
-#endif
 }

 // ----------------------------------------------------------------------------
@ -447,8 +423,8 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 3.3f);
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 3.3f);
 }

 // ----------------------------------------------------------------------------
@ -469,6 +445,26 @@ void tuple_length_test()

 }

+// ----------------------------------------------------------------------------
+// - testing swap -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+void tuple_swap_test()
+{
+  tuple<int, float, double> t1(1, 2.0f, 3.0), t2(4, 5.0f, 6.0);
+  swap(t1, t2);
+  BOOST_CHECK(get<0>(t1) == 4);
+  BOOST_CHECK(get<1>(t1) == 5.0f);
+  BOOST_CHECK(get<2>(t1) == 6.0);
+  BOOST_CHECK(get<0>(t2) == 1);
+  BOOST_CHECK(get<1>(t2) == 2.0f);
+  BOOST_CHECK(get<2>(t2) == 3.0);
+
+  int i = 1,j = 2;
+  boost::tuple<int&> t3(i), t4(j);
+  swap(t3, t4);
+  BOOST_CHECK(i == 2);
+  BOOST_CHECK(j == 1);
+}



@ -489,6 +485,7 @@ int test_main(int, char *[]) {
  cons_test();
  const_tuple_test();
  tuple_length_test();
+  tuple_swap_test();
  return 0;
 }
Author	SHA1	Message	Date
Peter Dimov	fb55aa6d4d	Add OS X to Travis	2017-11-07 16:13:33 +02:00
Peter Dimov	bbf1609d82	Merge branch 'develop'	2017-11-07 16:11:43 +02:00
Peter Dimov	889ff6de9f	Add .travis.yml	2017-11-07 15:17:15 +02:00
Rene Rivera	895af7c97a	Add, and update, documentation build targets.	2016-10-07 23:07:37 -05:00
Joel de Guzman	158c7ef640	Fixes Ticket #12064	2016-03-13 08:04:40 +08:00
Joel de Guzman	68eff7df4b	Merge pull request #7 from AMDmi3/patch-1 Only check for BOOST_GCC when it's defined	2016-03-02 00:38:58 +08:00
Dmitry Marakasov	8b6613e592	Only check for BOOST_GCC when it's defined This fixes warnings with clang: /usr/local/include/boost/tuple/detail/tuple_basic.hpp:44:5: warning: 'BOOST_GCC' is not defined, evaluates to 0 [-Wundef]	2016-03-01 13:54:12 +03:00
Joel de Guzman	b54dd8073b	Merge pull request #6 from K-ballo/boostbook Ported documentation to boostbook	2014-08-23 07:07:07 +08:00
K-ballo	b4f05902b8	Ported documentation to boostbook	2014-08-22 18:50:32 -03:00
Joel de Guzman	38ccaa9fa1	Merge pull request #5 from danieljames/metadata Create metadata file.	2014-08-19 06:08:54 +08:00
Daniel James	4fb261873e	Add metadata file.	2014-08-18 15:58:46 +01:00
Joel de Guzman	bc8ada354a	Merge pull request #4 from MarcelRaad/patch-1 Make tuple constructor explicit	2014-06-03 23:36:47 +08:00
Marcel Raad	8bdf2a9c58	Make tuple constructor explicit Otherwise everything implicitly convertible to the data type of the first element is implicitly convertible to a boost::tuple, which has led to long-unnoticed bugs in production code. This change is also consistent with the TR1 and C++11 tuple.	2014-06-03 14:32:44 +02:00
Joel de Guzman	d77e569c89	Merge pull request #3 from boostorg/develop Merge some changes to master.	2014-05-12 07:27:34 +08:00
Joel de Guzman	c17f1ec5b2	Merge pull request #1 from timblechmann/topic/silence_warning tuple: silence gcc warning	2014-04-17 08:53:51 +08:00
Joel de Guzman	476a5c155e	Merge pull request #2 from Lastique/patch-1 Remove unused local typedef	2014-04-17 08:53:12 +08:00
Daniel James	7f09162df7	Create merge base for git.	2014-04-06 14:40:59 +01:00
Andrey Semashev	f9b3dcb203	Remove unused local typedef Remove unused function-local typedef to avoid warnings with GCC 4.8.	2014-03-08 10:58:09 +03:00
Tim Blechmann	f4a6eafdb3	tuple: silence gcc warning	2013-12-07 14:40:49 +01:00
Stephen Kelly	ffb3bc75fa	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #elif...#else...#endif blocks. [SVN r86247]	2013-10-11 23:19:44 +00:00
Stephen Kelly	3cd92cec82	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifdef...#else...#endif blocks. [SVN r86246]	2013-10-11 23:19:17 +00:00
Stephen Kelly	10e946199d	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifndef...#else...#endif blocks. [SVN r86245]	2013-10-11 23:17:48 +00:00
Stephen Kelly	5f7673641a	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifndef...#endif conditions. [SVN r86244]	2013-10-11 23:15:00 +00:00
Stephen Kelly	39181642d2	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifdef...#endif blocks. [SVN r86243]	2013-10-11 23:13:10 +00:00
Stephen Kelly	27d746b9e3	Remove obsolete files. [SVN r86242]	2013-10-11 23:11:35 +00:00
Stephen Kelly	2f49af7db8	Remove use of obsolete BOOST_NO_TEMPLATED_STREAMS macro. It was only defined for no-longer-supported-gcc. [SVN r86062]	2013-09-30 15:56:52 +00:00
Stephen Kelly	40e5cd5e6c	Tuple: Remove obsolete MSVC version check. [SVN r86038]	2013-09-30 00:21:22 +00:00
Stephen Kelly	2798fa2168	Remove use of obsolete BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE macro. [SVN r85897]	2013-09-25 10:29:59 +00:00
Stephen Kelly	136ffd5057	Remove use of obsolete BOOST_EXPLICIT_TEMPLATE_NON_TYPE macro. [SVN r85895]	2013-09-25 10:29:10 +00:00
Steven Watanabe	72cd223130	Merge [67751] from the trunk. [SVN r71382]	2011-04-19 20:10:43 +00:00
Steven Watanabe	f904cd5d69	Revert [67111] (addition of boost/detail/iomanip.hpp) and all the commits that depend on it. ([68137], [68140], [68141], [68154], and [68165]). [SVN r68168]	2011-01-15 08:11:51 +00:00
Bryce Adelstein-Lelbach	2b30eb2225	Replacing the use of <iomanip> with <boost/detail/iomanip.hpp> across Boost. On Linux, GNU's libstdc++, which is the default stdlib for icc and clang, cannot parse the <iomanip> header in version 4.5+ (which thankfully neither compiler advises the use of yet), as it's original C++98-friendly implementation has been replaced with a gnu++0x implementation. <boost/detail/iomanip.hpp> is a portable implementation of <iomanip>, providing boost::detail::setfill, boost::detail::setbase, boost::detail::setw, boost::detail::setprecision, boost::detail::setiosflags and boost::detail::resetiosflags. [SVN r68140]	2011-01-14 02:35:58 +00:00
Steven Watanabe	9fbc9b4cc6	Handle width correctly. Fixes #5046 . [SVN r67751]	2011-01-07 15:22:13 +00:00
Steven Watanabe	a2c9608ef0	Merge Tuple from the trunk [SVN r67590]	2011-01-02 20:25:11 +00:00
Steven Watanabe	9d64187c34	Add an element-wise swap for Boost.Tuple. Fixes #1324 [SVN r62686]	2010-06-09 19:30:35 +00:00
Steven Watanabe	7b6203747a	Use an inline function instead of a static object for boost::tuples::ignore, avoiding problems with the ODR and Borland precompiled headers. Fixes #2656 [SVN r62684]	2010-06-09 19:00:56 +00:00
Steven Watanabe	1b07c1a2d4	Reimplement boost::tuples::element and boost::tuples::get to make better use of memoization. Fixes #2130 [SVN r62683]	2010-06-09 18:28:16 +00:00
Steven Watanabe	052b3db77f	Make reading a tuple work with std::noskipws. Fixes #1920 [SVN r62678]	2010-06-09 17:45:24 +00:00
Troy D. Straszheim	d908a5d566	rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back [SVN r56942]	2009-10-17 02:07:38 +00:00
Troy D. Straszheim	e36faf7e25	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Troy D. Straszheim	a75a686fae	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Troy D. Straszheim	509bd47ef8	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Steven Watanabe	41ebb2ee6c	Merge [51862], [53211], [53212], and [53218] from the trunk [SVN r53872]	2009-06-13 18:30:31 +00:00
Steven Watanabe	b7c2e00b64	Fix typos/markup problems in tuple docs. Fixes # [SVN r53218]	2009-05-23 18:59:02 +00:00
Steven Watanabe	e89ea11d63	Avoid ambiguites between std and boost components in C++0x mode. Fixes #3026 [SVN r53212]	2009-05-23 16:49:33 +00:00
Steven Watanabe	08277fd057	Allow printing an empty tuple [SVN r53211]	2009-05-23 16:39:13 +00:00
Daniel James	700d64acc8	Merge misc. changes from trunk, mostly minor documentation fixes. Merged revisions 48412,50921,51042,51369,51386-51387,51506-51507,51668,51802,51804,51881 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r48412 \| danieljames \| 2008-08-28 11:23:33 +0100 (Thu, 28 Aug 2008) \| 1 line Fix a typo. Thanks to Jon Biggar. ........ r50921 \| danieljames \| 2009-01-31 09:36:38 +0000 (Sat, 31 Jan 2009) \| 1 line Remove executable flag from preprocess.cmd. It was a mistake to add it. ........ r51042 \| danieljames \| 2009-02-06 00:04:44 +0000 (Fri, 06 Feb 2009) \| 1 line Ignore some version control files in inspect. ........ r51369 \| danieljames \| 2009-02-21 18:49:48 +0000 (Sat, 21 Feb 2009) \| 1 line Minor markup fix in concept check documentation. ........ r51386 \| danieljames \| 2009-02-22 11:53:28 +0000 (Sun, 22 Feb 2009) \| 1 line Add index.html file for compose, as our server setup doesn't support index.htm files. ........ r51387 \| danieljames \| 2009-02-22 11:53:48 +0000 (Sun, 22 Feb 2009) \| 5 lines Add missing index.html file for MPI and GIL. All the top level libraries now have index.html files but several sub-libraries don't. I'm not sure it's worth adding them as many of them don't have appropriate subdirectories anyway. ........ r51506 \| danieljames \| 2009-03-01 14:16:00 +0000 (Sun, 01 Mar 2009) \| 1 line Update links to command line invocation. ........ r51507 \| danieljames \| 2009-03-01 14:16:24 +0000 (Sun, 01 Mar 2009) \| 1 line Use xpointer attributes in the boost build documentation. ........ r51668 \| danieljames \| 2009-03-09 20:56:51 +0000 (Mon, 09 Mar 2009) \| 1 line Redirect to the Trac wiki instead of the old one. ........ r51802 \| danieljames \| 2009-03-16 20:21:05 +0000 (Mon, 16 Mar 2009) \| 1 line Use paragraphs inside purpose tags. ........ r51804 \| danieljames \| 2009-03-16 20:21:46 +0000 (Mon, 16 Mar 2009) \| 1 line Give the variablelist a margin. ........ r51881 \| danieljames \| 2009-03-21 15:35:35 +0000 (Sat, 21 Mar 2009) \| 1 line Fix html. ........ [SVN r51897]	2009-03-22 10:42:48 +00:00
Daniel James	70e04d2965	Fix html. [SVN r51881]	2009-03-21 15:35:35 +00:00
Joel de Guzman	451415ebce	fixed tuples::length not having a specialization for const tuple<> and const null_type [SVN r51862]	2009-03-20 01:21:42 +00:00
Steven Watanabe	ff6b861ed7	Merge [51449] from the trunk. [SVN r51618]	2009-03-05 03:56:52 +00:00
Steven Watanabe	e9dc95ae93	Supress gcc warning. Fixes #2388 [SVN r51449]	2009-02-26 02:35:44 +00:00
Troy D. Straszheim	99039c3db8	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Michael A. Jackson	1d1970d81d	Updating dependency information for modularized libraries. [SVN r49628]	2008-11-07 17:05:27 +00:00
Michael A. Jackson	4e452cb734	Updating CMake files to latest trunk. Added dependency information for regression tests and a few new macros for internal use. [SVN r49627]	2008-11-07 17:02:56 +00:00
Michael A. Jackson	776be602e5	Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor [SVN r49510]	2008-11-01 13:15:41 +00:00
Beman Dawes	785ada83f4	With his kind permission, change Jaakko "Järvi" to "Jarvi" [SVN r46809]	2008-06-28 13:57:20 +00:00
Beman Dawes	a30a7f9604	With his kind permission, change Jaakko "Järvi" to "Jarvi" [SVN r46808]	2008-06-28 13:45:21 +00:00
Daniel James	57c6d6fd00	Merged revisions 43206,43208-43213 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43206 \| danieljames \| 2008-02-10 09:55:03 +0000 (Sun, 10 Feb 2008) \| 1 line Fix some broken links. ........ r43209 \| danieljames \| 2008-02-10 14:56:22 +0000 (Sun, 10 Feb 2008) \| 1 line Link to people pages on the website, as they've been removed from the download. ........ r43210 \| danieljames \| 2008-02-10 15:02:17 +0000 (Sun, 10 Feb 2008) \| 1 line Point links to the pages that used to be in 'more' to the site. ........ r43212 \| danieljames \| 2008-02-10 16:10:16 +0000 (Sun, 10 Feb 2008) \| 1 line Fix links on the home page as well. ........ r43213 \| danieljames \| 2008-02-10 16:21:22 +0000 (Sun, 10 Feb 2008) \| 1 line Generated documentation which is no longer generated. ........ [SVN r43214]	2008-02-10 16:39:38 +00:00
Daniel James	62d366fa68	Link to people pages on the website, as they've been removed from the download. [SVN r43209]	2008-02-10 14:56:22 +00:00
Beman Dawes	591a9a3ddf	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	310c0cda3f	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
Vladimir Prus	d08c9bfab1	Update to V2 [SVN r38530]	2007-08-08 19:42:04 +00:00
nobody	e3455e7ddf	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Jaakko Järvi	ec599f4b77	Merged a typofix from trunk to branch [SVN r36897]	2007-02-06 00:30:57 +00:00
Jaakko Järvi	19b8004830	Fixed a typo. [SVN r36896]	2007-02-06 00:23:26 +00:00
Daniel James	0af5b76442	Merge fixed links from RC_1_34_0. [SVN r36660]	2007-01-07 23:50:56 +00:00
Daniel James	31af4e8ec5	Fix the license link (again - I got it wrong the first time, sorry). [SVN r36657]	2007-01-07 23:18:58 +00:00
Daniel James	c493a8938d	Fix a couple of links. [SVN r36656]	2007-01-07 22:58:41 +00:00
Daniel James	8bc4064ec5	Fix a broken link. [SVN r36655]	2007-01-07 22:55:23 +00:00
Beman Dawes	3e7b7f407d	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Beman Dawes	defe1c94d6	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
Rene Rivera	88163596d0	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
nobody	588c928e5a	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00
Ralf W. Grosse-Kunstleve	76c2151830	avoid g++ -Wall -W "unused parameter" warnings [SVN r32373]	2006-01-22 19:29:32 +00:00
Jaakko Järvi	2d13a60d05	applied patch by Rupert Kittinger, avoids potentially undefined behavior [SVN r30690]	2005-08-26 16:03:05 +00:00
John Maddock	9c6ef41dfe	Large patch from Ulrich Eckhardt to fix support for EVC++ 4. [SVN r30670]	2005-08-25 16:27:28 +00:00
Douglas Gregor	5686969287	Merged from 1.33.0 release [SVN r30540]	2005-08-12 13:02:37 +00:00
Stefan Slapeta	a17ce206f2	replaced BOOST_TEST [SVN r27057]	2005-02-03 13:55:45 +00:00
Joaquín M. López Muñoz	34690282fe	fixes in element<> for BCB compilers, with help from Tobias Schwinger [SVN r25763]	2004-10-18 06:03:18 +00:00
Aleksey Gurtovoy	bc3d37ec2b	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
Douglas Gregor	eea1937afc	Converted to Boost Software License, Version 1.0 [SVN r24096]	2004-07-27 03:43:34 +00:00
Douglas Gregor	8820994ffd	Doug Gregor -> Douglas Gregor [SVN r24016]	2004-07-25 02:29:29 +00:00
Toon Knapen	045d761ab5	suppressed scoping the call get_class to the detail namespace [SVN r23113]	2004-06-17 13:51:33 +00:00
Toon Knapen	63c93b59b4	port to vacpp: added default template arguments explicitly (Joaquin M Lopez) removed member template keyword (Toon Knapen) [SVN r23109]	2004-06-17 07:01:13 +00:00
Dave Abrahams	78572fca7b	Bug fix for vc6 [SVN r20866]	2003-11-19 22:01:52 +00:00
Joel de Guzman	ad29f96e5b	updated swallow_assign constness bug [SVN r20520]	2003-10-28 09:42:43 +00:00
Joel de Guzman	9734556efe	made "ingnore" a const object to avoid linker errors [SVN r20449]	2003-10-21 23:25:17 +00:00
Jaakko Järvi	c8e03a518b	added praise for Dave for improving tuple support on non-partial template specialization compilers [SVN r19965]	2003-09-08 15:10:04 +00:00
Dave Abrahams	e4b869219b	More complete functionality for compilers without partial specialization. [SVN r19925]	2003-09-05 16:52:55 +00:00
Dave Abrahams	eef0e01c8d	Adjust for changed test library name [SVN r19924]	2003-09-05 16:18:53 +00:00
Jaakko Järvi	41d649b08c	cleaning up after previous commit [SVN r19688]	2003-08-18 19:35:29 +00:00
Jaakko Järvi	122bf636f5	getting rid of some library specific macros and using BOOST_NO_EXPLICIT_- FUNCTION_TEMPLATE_ARGUMENTS related helper macros from the config library [SVN r19687]	2003-08-18 19:33:47 +00:00
Jaakko Järvi	359eaeecbf	added tests to ensure correct constness behaviour [SVN r18871]	2003-06-26 15:19:01 +00:00
Jaakko Järvi	28e34eb757	fixed a typo [SVN r18386]	2003-05-12 14:51:42 +00:00
Dave Abrahams	5ea6623d49	restore from disk crash [SVN r18353]	2003-05-08 02:19:10 +00:00
Jaakko Järvi	d349450992	fixed a few links [SVN r18344]	2003-05-07 16:01:33 +00:00
Jaakko Järvi	8b4daa1385	patch of a patch [SVN r17706]	2003-03-03 16:45:55 +00:00
Jaakko Järvi	1972959fda	element<T>::type takes constness into consideration [SVN r17666]	2003-02-26 23:10:55 +00:00
Jaakko Järvi	496cc84960	a patch for borland [SVN r17660]	2003-02-26 16:04:56 +00:00
Jaakko Järvi	c1a28e5d81	typofix [SVN r17557]	2003-02-20 15:30:48 +00:00
Björn Karlsson	4d4fe0010f	Added copyright statement [SVN r17193]	2003-02-04 11:54:01 +00:00
Dave Abrahams	8992af95d1	Link bug workaround for MSVC and old Dec CXX [SVN r16342]	2002-11-20 13:17:52 +00:00
Jaakko Järvi	ae40fce7c9	added namespace qualifiers to make MIPS PRO happy [SVN r16033]	2002-10-31 18:14:29 +00:00
Jaakko Järvi	607b65a946	fixing a borland warning [SVN r15810]	2002-10-08 19:24:36 +00:00
Jaakko Järvi	2c213c8295	fix one borland warning [SVN r15808]	2002-10-08 18:43:52 +00:00
Jaakko Järvi	5b8506c39b	typo fixes [SVN r15652]	2002-10-02 16:51:43 +00:00
Jaakko Järvi	22f56bbe58	fixed Bemans name in a comment [SVN r15594]	2002-10-01 03:26:10 +00:00
Ralf W. Grosse-Kunstleve	fb8fa3c7b6	work-around for MIPSpro bug [SVN r15574]	2002-09-30 19:45:22 +00:00
Dave Abrahams	cc5a2ae388	Fixes which make it possible to declare with reference elements [SVN r15532]	2002-09-28 07:25:27 +00:00
Jaakko Järvi	4cd544f4c1	applied patch Markus Schöpflin, ::template replaced with ::BOOST_NESTED_TEMPLATE [SVN r15466]	2002-09-20 15:55:10 +00:00
Jaakko Järvi	74a2ab1242	changed jamfile includes from <include> to <sysinclude> [SVN r15305]	2002-09-13 16:26:12 +00:00
Jaakko Järvi	7896766f8f	a fix of a fix [SVN r15278]	2002-09-12 20:59:05 +00:00
Jaakko Järvi	0a33edd21d	workaround for isspace and metrowerks [SVN r15277]	2002-09-12 20:50:10 +00:00
Jaakko Järvi	53c1bb2c20	removed an extraneous include [SVN r14993]	2002-08-20 15:54:11 +00:00
Jaakko Järvi	ea8d71487d	workaround for boost test library problem [SVN r14992]	2002-08-20 15:51:36 +00:00
Jaakko Järvi	6a92d10f25	added a redirection index.html file [SVN r14898]	2002-08-15 18:26:17 +00:00
Jaakko Järvi	3570bdb6b6	fixed some warningns about unused variables, added Jamfile [SVN r14854]	2002-08-14 20:55:52 +00:00