|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r53218 - trunk/libs/tuple/doc
From: steven_at_[hidden]
Date: 2009-05-23 14:59:04
Author: steven_watanabe
Date: 2009-05-23 14:59:02 EDT (Sat, 23 May 2009)
New Revision: 53218
URL: http://svn.boost.org/trac/boost/changeset/53218
Log:
Fix typos/markup problems in tuple docs. Fixes #
Text files modified:
trunk/libs/tuple/doc/design_decisions_rationale.html | 52 +++++++-------
trunk/libs/tuple/doc/tuple_advanced_interface.html | 38 +++++-----
trunk/libs/tuple/doc/tuple_users_guide.html | 140 ++++++++++++++++++++-------------------
3 files changed, 119 insertions(+), 111 deletions(-)
Modified: trunk/libs/tuple/doc/design_decisions_rationale.html
==============================================================================
--- trunk/libs/tuple/doc/design_decisions_rationale.html (original)
+++ trunk/libs/tuple/doc/design_decisions_rationale.html 2009-05-23 14:59:02 EDT (Sat, 23 May 2009)
@@ -1,3 +1,4 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<title>Design decisions rationale for Boost Tuple Library</title>
@@ -20,8 +21,8 @@
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 {
+This is accomplished with using declarations (suggested by Dave Abrahams):</p>
+<pre><code>namespace boost {
namespace tuples {
...
// All library code
@@ -32,8 +33,8 @@
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.
+</code></pre>
+<p>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<N></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.
@@ -54,9 +55,9 @@
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:
+Both gcc and edg compilers reject using declarations where the namespace and class names are identical:</p>
-<code><pre>namespace boost {
+<pre><code>namespace boost {
namespace tuple {
... tie(...);
class tuple;
@@ -66,13 +67,13 @@
using tuple::tuple; // error
...
}
-</pre></code>
+</code></pre>
-Note, however, that a corresponding using declaration in the global namespace seems to be ok:
+<p>Note, however, that a corresponding using declaration in the global namespace seems to be ok:</p>
-<code><pre>
+<pre><code>
using boost::tuple::tuple; // ok;
-</pre></code>
+</code></pre>
<h2>The end mark of the cons list (nil, null_type, ...)</h2>
@@ -80,14 +81,15 @@
<p>
Tuples are internally represented as <code>cons</code> lists:
-<code><pre>tuple<int, int>
-</pre></code>
-inherits from
-<code><pre>cons<int, cons<int, null_type> >
+<pre><code>tuple<int, int>
+</code></pre>
+<p>inherits from</p>
+<pre><code>cons<int, cons<int, null_type> >
</code></pre>
+<p>
<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).
+Other names considered were <i>null_t</i> and <i>unit</i> (the empty tuple type in SML).</p>
<p>
Note that <code>null_type</code> is the internal representation of an empty tuple: <code>tuple<></code> inherits from <code>null_type</code>.
</p>
@@ -95,22 +97,22 @@
<h2>Element indexing</h2>
<p>
-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:
+Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:</p>
<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<N>(a)</code>, or <code>a.get<N>()</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>Tuple access with the syntax <code>get<N>(a)</code>, or <code>a.get<N>()</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>
<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<0>() == a.get(_1st) == a[_1st] == a(_1st);
-</pre></code>
+<pre><code>a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
+</code></pre>
-We chose not to provide more than one indexing method for the following reasons:
+<p>We chose not to provide more than one indexing method for the following reasons:</p>
<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>
@@ -125,18 +127,18 @@
<h2>Tuple comparison</h2>
-The comparison operator implements lexicographical order.
-Other orderings were considered, mainly dominance (<i>a < 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.
+<p>The comparison operator implements lexicographical order.
+Other orderings were considered, mainly dominance (<i>a < 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.</p>
<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.
+Streams that have character types not convertible back and forth to long thus fail to compile.</p>
-This may be revisited at some point. The two possible solutions are:
+<p>This may be revisited at some point. The two possible solutions are:</p>
<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
Modified: trunk/libs/tuple/doc/tuple_advanced_interface.html
==============================================================================
--- trunk/libs/tuple/doc/tuple_advanced_interface.html (original)
+++ trunk/libs/tuple/doc/tuple_advanced_interface.html 2009-05-23 14:59:02 EDT (Sat, 23 May 2009)
@@ -15,39 +15,39 @@
<h2>Metafunctions for tuple types</h2>
<p>
-Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression.
+Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression.</p>
-<code><pre>element<N, T>::type</pre></code>
+<pre><code>element<N, T>::type</code></pre>
-gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well.
+<p>gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well.
Note that the constness of <code>T</code> does not affect reference type
elements.
</p>
-<code><pre>length<T>::value</pre></code>
+<pre><code>length<T>::value</code></pre>
-gives the length of the tuple type <code>T</code>.
+<p>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
+For example, the tuple </p>
-<code><pre>tuple<A, B, C, D></pre></code>
+<pre><code>tuple<A, B, C, D></code></pre>
- inherits from the type
-<code><pre>cons<A, cons<B, cons<C, cons<D, null_type> > > >
-</pre></code>
+<p>inherits from the type</p>
+<pre><code>cons<A, cons<B, cons<C, cons<D, null_type> > > >
+</code></pre>
-The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
+<p>The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
<code>tuple<A>::inherited</code> is the type <code>cons<A, null_type></code>.
</p>
<h4>Empty tuple</h4>
<p>
-The internal representation of the empty tuple <code>tuple<></code> is <code>null_type</code>.
+The internal representation of the empty tuple <code>tuple<></code> is <code>null_type</code>.
</p>
<h4>Head and tail</h4>
@@ -83,11 +83,11 @@
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:
+A cons list can be constructed from its head and tail. The prototype of the constructor is:</p>
<pre><code>cons(typename access_traits<head_type>::parameter_type h,
const tail_type& 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>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.
@@ -98,16 +98,16 @@
<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:
+The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:</p>
<ol>
-<li><code>access_traits<T>::non_const_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<T>::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmember and member <code>get</code> functions, and the <code>get_head</code> function).</li>
<li><code>access_traits<T>::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
<li><code>access_traits<T>::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<T>::type</code> implements the following type mapping:
+<p>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<T>::type</code> implements the following type mapping:</p>
<ul>
<li><i>any reference type</i> -> <i>compile time error</i>
</li>
@@ -119,7 +119,7 @@
</li>
</ul>
-Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see The make_tuple function.)
+<p>Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see The make_tuple function.)
</p>
<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost.
Modified: trunk/libs/tuple/doc/tuple_users_guide.html
==============================================================================
--- trunk/libs/tuple/doc/tuple_users_guide.html (original)
+++ trunk/libs/tuple/doc/tuple_users_guide.html 2009-05-23 14:59:02 EDT (Sat, 23 May 2009)
@@ -1,3 +1,4 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>The Boost Tuple Library</title>
@@ -53,20 +54,22 @@
<h2><a name="using_library">Using the library</a></h2>
-<p>To use the library, just include:
+<p>To use the library, just include:</p>
<pre><code>#include "boost/tuple/tuple.hpp"</code></pre>
-<p>Comparison operators can be included with:
+<p>Comparison operators can be included with:</p>
<pre><code>#include "boost/tuple/tuple_comparison.hpp"</code></pre>
-<p>To use tuple input and output operators,
+<p>To use tuple input and output operators,</p>
<pre><code>#include "boost/tuple/tuple_io.hpp"</code></pre>
-Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
+<p>Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.</p>
-<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.
+<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.</p>
<h2><a name = "tuple_types">Tuple types</a></h2>
@@ -80,11 +83,11 @@
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).
+be copied, or that are not default constructible (see 'Constructing tuples'
+ below). </p>
<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):
+For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):</p>
<pre><code>tuple<int>
tuple<double&, const double&, const double, double*, const double*>
@@ -98,7 +101,7 @@
<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 <= <i>k</i> <= <i>n</i>.
-For example:
+For example:</p>
<pre><code>tuple<int, double>()
tuple<int, double>(1)
tuple<int, double>(1, 3.14)
@@ -106,7 +109,7 @@
<p>
If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
-For example.
+For example.</p>
<pre><code>class X {
X();
@@ -118,7 +121,7 @@
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
</code></pre>
-In particular, reference types do not have a default initialization:
+<p>In particular, reference types do not have a default initialization: </p>
<pre><code>tuple<double&>() // error: reference must be
// initialized explicitly
@@ -134,7 +137,7 @@
</code></pre>
<p>Using an initial value for an element that cannot be copied, is a compile
-time error:
+time error:</p>
<pre><code>class Y {
Y(const Y&);
@@ -148,15 +151,15 @@
tuple<char[10], Y>(); // ok
</code></pre>
-Note particularly that the following is perfectly ok:
-<code><pre>Y y;
+<p>Note particularly that the following is perfectly ok:</p>
+<pre><code>Y y;
tuple<char(&)[10], Y&>(a, y);
</code></pre>
-It is possible to come up with a tuple type that cannot be constructed.
+<p>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<char[10], int&></code>.
+For example: <code>tuple<char[10], int&></code>.</p>
<p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
</p>
@@ -165,19 +168,19 @@
<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:
+This makes the construction more convenient, saving the programmer from explicitly specifying the element types:</p>
<pre><code>tuple<int, int, double> 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:
+By default, the element types are deduced to the plain non-reference types. E.g.: </p>
<pre><code>void foo(const A& a, B& b) {
...
make_tuple(a, b);
</code></pre>
-The <code>make_tuple</code> invocation results in a tuple of type <code>tuple<A, B></code>.
+<p>The <code>make_tuple</code> invocation results in a tuple of type <code>tuple<A, B></code>.</p>
<p>
Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied.
@@ -185,8 +188,9 @@
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:
+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 example below).
+For example:</p>
<pre><code>A a; B b; const A ca = a;
make_tuple(cref(a), b); // creates tuple<const A&, B>
@@ -198,19 +202,19 @@
<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:
+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:</p>
<pre><code>make_tuple("Donald", "Daisy");
</code></pre>
-This creates an object of type <code>tuple<const char (&)[7], const char (&)[6]></code>
+<p>This creates an object of type <code>tuple<const char (&)[7], const char (&)[6]></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.
+non-const array type one must use the <code>ref</code> wrapper.</p>
<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):
+but such a tuple cannot be constructed with <code>make_tuple</code> (a const qualified function type would result, which is illegal):</p>
<pre><code>void f(int i);
...
make_tuple(&f); // tuple<void (*)(int)>
@@ -222,19 +226,19 @@
<h2><a name = "accessing_elements">Accessing tuple elements</a></h2>
<p>
-Tuple elements are accessed with the expression:
+Tuple elements are accessed with the expression:</p>
<pre><code>t.get<N>()
</code></pre>
-or
+<p>or</p>
<pre><code>get<N>(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.
+<p>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:
+Violations of these constraints are detected at compile time. Examples:</p>
<pre><code>double d = 2.7; A a;
tuple<int, double&, const A&> t(1, d, a);
@@ -253,16 +257,18 @@
++get<0>(t); // ok, can be used as any variable
</code></pre>
+<p>
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<N>(a_tuple)</code> when writing code that shoud compile with MSVC++ 6.0.
+Hence, all <code>get</code> calls should be qualified as: <code>tuples::get<N>(a_tuple)</code> when writing code that should compile with MSVC++ 6.0.
+</p>
<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:
+For example:</p>
<pre><code>class A {};
class B : public A {};
@@ -274,32 +280,32 @@
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>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>
<p>
-Note that assignment is also defined from <code>std::pair</code> types:
+Note that assignment is also defined from <code>std::pair</code> types:</p>
<pre><code>tuple<float, int> a = std::make_pair(1, 'a');
</code></pre>
<h2><a name = "relational_operators">Relational operators</a></h2>
<p>
-Tuples reduce the operators <code>==, !=, <, >, <=</code> and <code>>=</code> to the corresponding elementary operators.
+Tuples reduce the operators <code>==, !=, <, >, <=</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:
+The equality operators for two tuples <code>a</code> and <code>b</code> are defined as:</p>
<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><, >, <=</code> and <code>>=</code> implement a lexicographical ordering.
+<p>The operators <code><, >, <=</code> and <code>>=</code> implement a lexicographical ordering.</p>
<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.
+Note that an attempt to compare two tuples of different lengths results in a compile time error.
+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>
-<p>Examples:
+<p>Examples:</p>
<pre><code>tuple<std::string, int, A> t1(std::string("same?"), 2, A());
tuple<std::string, long, A> t2(std::string("same?"), 2, A());
@@ -316,7 +322,7 @@
<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>):
+They are constructed with a call to the <code>tie</code> function template (cf. <code>make_tuple</code>):</p>
<pre><code>int i; char c; double d;
...
@@ -329,26 +335,26 @@
</p>
<p>
-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
+A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:</p>
<pre><code>int i; char c; double d;
tie(i, c, d) = make_tuple(1,'a', 5.5);
std::cout << i << " " << c << " " << d;
</code></pre>
-This code prints <code>1 a 5.5</code> to the standard output stream.
+<p>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.
+It is convenient when calling functions which return tuples.</p>
<p>
-The tying mechanism works with <code>std::pair</code> templates as well:
+The tying mechanism works with <code>std::pair</code> templates as well:</p>
<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):
+<p>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):</p>
<pre><code>char c;
tie(tuples::ignore, c) = std::make_pair(1, 'a');
@@ -374,10 +380,10 @@
cout << a;
</code></pre>
-outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>
+<p>outputs the tuple as: <code>(1.0 2 Howdy folks!)</code></p>
<p>
-The library defines three <i>manipulators</i> for changing the default behavior:
+The library defines three <i>manipulators</i> for changing the default behavior:</p>
<ul>
<li><code>set_open(char)</code> defines the character that is output before the first
element.</li>
@@ -387,27 +393,27 @@
elements.</li>
</ul>
-Note, that these manipulators are defined in the <code>tuples</code> subnamespace.
-For example:
-<code><pre>cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
+<p>Note, that these manipulators are defined in the <code>tuples</code> subnamespace.
+For example:</p>
+<pre><code>cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
</code></pre>
-outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code>
+<p>outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code></p>
<p>The same manipulators work with <code>operator>></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:
+<p>The code:</p>
-<code><pre>tuple<int, int, int> i;
+<pre><code>tuple<int, int, int> i;
tuple<int, int> j;
cin >> i;
-cin >> tuples::set_open('[') >> tuples::set_close(']') >> tules::set_delimiter(':');
+cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');
cin >> j;
</code></pre>
-reads the data into the tuples <code>i</code> and <code>j</code>.
+<p>reads the data into the tuples <code>i</code> and <code>j</code>.</p>
<p>
Note that extracting tuples with <code>std::string</code> or C-style string
@@ -417,9 +423,9 @@
<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:
+<p>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:</p>
<pre><code>class hand_made_tuple {
A a; B b; C c;
@@ -435,7 +441,7 @@
hmt.getA(); hmt.getB(); hmt.getC();
</code></pre>
-and this code:
+<p>and this code:</p>
<pre><code>tuple<A, B, C> t(A(), B(), C());
t.get<0>(); t.get<1>(); t.get<2>();
@@ -446,23 +452,23 @@
<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:
+For example, suppose that the following functions <code>f1</code> and <code>f2</code> have equivalent functionalities:</p>
<pre><code>void f1(int&, double&);
tuple<int, double> f2();
</code></pre>
-Then, the call #1 may be slightly faster than #2 in the code below:
+<p>Then, the call #1 may be slightly faster than #2 in the code below:</p>
<pre><code>int i; double d;
...
f1(i,d); // #1
tie(i,d) = f2(); // #2
</code></pre>
-See
+<p>See
[1,
<a href="#publ_2">2</a>]
- for more in-depth discussions about efficiency.
+ for more in-depth discussions about efficiency.</p>
<h4>Effect on Compile Time</h4>
@@ -470,7 +476,7 @@
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.
+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
[1,
<a href="#publ_2">2</a>]
@@ -492,10 +498,10 @@
</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, 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.
+<p>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::pairs.
+The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.</p>
<h2><a name = "references">References</a></h2>
<p>
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk