forked from boostorg/tuple
Compare commits
7 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 2d62dc5f16 | |||
| 2a2632a159 | |||
| b8cca277e5 | |||
| c10fd424bc | |||
| 984cbdc728 | |||
| 09a730c9bc | |||
| 43ea26d05e |
@ -1,132 +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 at the <code>boost</code> namespace.
|
||||
The common principle is that domain libraries (like <i>graph</i>, <i>python</i>) should be on a separate
|
||||
sub-namespace, 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.
|
||||
As a result of the discussion, tuple definitions are now directly under the <code>boost</code> namespace.
|
||||
<p>
|
||||
|
||||
<h4>For those who are really interested in namespaces</h4>
|
||||
|
||||
<p>
|
||||
Note! The following discussion is not relevant for the Tuple library, as the 'no
|
||||
sub-namespace' decision was taken, but it may be useful for other library writers.
|
||||
</p>
|
||||
<p>
|
||||
In the original tuple library submission, all names were under the namespace <code>tuples</code>. This brought up the issue of naming
|
||||
sub-namespaces.
|
||||
The rationale for not using the most natural name 'tuple' was to avoid having an identical name with the tuple template. Namespace names are, however, not generally in plural form in boost libraries. Further, no real trouble was reported for using the same name for a namespace and a class.
|
||||
But we found some trouble after all.
|
||||
One solution proposed to the dilemma of introducing a sub-namespace or not was as follows: use a
|
||||
sub-namespace but lift the most common names to the <code>boost</code> namespace with using declarations.
|
||||
Both gcc and edg compilers rejected such using declarations if the namespace and class names were identical:
|
||||
|
||||
<code><pre>namespace boost {
|
||||
namespace tuple {
|
||||
class cons;
|
||||
class tuple;
|
||||
...
|
||||
}
|
||||
using tuple::cons; // ok
|
||||
using tuple::tuple; // error
|
||||
...
|
||||
}
|
||||
</pre></code>
|
||||
|
||||
|
||||
Note, however, that a corresponding using declaration in the global namespace seemed 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<int, int>
|
||||
</pre></code>
|
||||
inherits from
|
||||
<code><pre>cons<int, cons<int, null_type> >
|
||||
</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<></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<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>
|
||||
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>
|
||||
|
||||
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 < 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>© Copyright Jaakko Järvi 2001.
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@ -1,131 +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>
|
||||
|
||||
|
||||
<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>tuple_element<N, T>::type</pre></code>
|
||||
|
||||
gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
|
||||
</p>
|
||||
|
||||
<code><pre>tuple_length<T>::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<A, B, C, D></pre></code>
|
||||
|
||||
inherits from the type
|
||||
<code><pre>cons<A, cons<B, cons<C, cons<D, null_type> > > >
|
||||
</pre></code>
|
||||
|
||||
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>.
|
||||
</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&) {};
|
||||
|
||||
template <class H, class T>
|
||||
inline void set_to_zero(cons<H, T>& 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 tuple_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>
|
||||
<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>tuple_access_traits</code></h4>
|
||||
<p>
|
||||
The template <code>tuple_access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
|
||||
<ol>
|
||||
<li><code>tuple_access_traits<T>::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>tuple_access_traits<T>::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
|
||||
<li><code>tuple_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:
|
||||
<ul>
|
||||
<li><i>any reference type</i> -> <i>compile time error</i>
|
||||
</li>
|
||||
<li><i>any array type</i> -> <i>constant reference to the array type</i>
|
||||
</li>
|
||||
<li><code>reference_wrapper<T></code> -> <code>T&</code>
|
||||
</li>
|
||||
<li><code>T</code> -> <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>Note, that the <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate hpp-file <code>reference_wrappers.hpp</code>, which can be included without including the rest of the tuple library.
|
||||
</p>
|
||||
|
||||
<A href="tuple_users_guide.html">Back to the user's guide</A>
|
||||
<hr>
|
||||
|
||||
<p>© Copyright Jaakko Järvi 2001.</p>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,521 +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 "deficiency", 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 "boost/tuple/tuple.hpp"</code></pre>
|
||||
|
||||
<p>Comparison operators can be included with:
|
||||
<pre><code>#include "boost/tuple/tuple_comparison.hpp"</code></pre>
|
||||
|
||||
<p>To use tuple input and output operators,
|
||||
|
||||
<pre><code>#include "boost/tuple/tuple_io.hpp"</code></pre>
|
||||
and add the <code>libs/tuple/src/tuple.hpp</code> file to your project.
|
||||
|
||||
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</code>.
|
||||
|
||||
<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, except for a non-reference type
|
||||
that is not copy constructible from a const qualified reference to that
|
||||
same type. In practice this means, that the element type must be <i>CopyConstructible</i> [C++ Standard 20.1.3]. (To be precise, CopyConstrucible is an unnecessary strong requirement for a valid element type, as the <code>operator&</code> is not used by the library.)
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Examples of types that are not allowed as tuple elements:
|
||||
|
||||
<ul>
|
||||
<li>classes that do not have a public copy constructor</li>
|
||||
<li>classes, where the copy constructor takes its argument as a non-const reference (cf. <code>auto_ptr</code>)
|
||||
<li>arrays</li>
|
||||
</ul>
|
||||
|
||||
Note that a reference to any of these non-copyable types is a valid element
|
||||
type.
|
||||
|
||||
<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<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*>
|
||||
</code></pre>
|
||||
|
||||
<p>
|
||||
The following code shows some invalid tuple instantiations:
|
||||
<pre><code>class Y {
|
||||
Y(const Y&);
|
||||
public:
|
||||
Y();
|
||||
};
|
||||
|
||||
tuple<Y> // not allowed, objects of type Y cannot be copied
|
||||
tuple<char[10]> // not allowed: arrays cannot be copied
|
||||
</code></pre>
|
||||
|
||||
Note however that <code>tuple<Y&></code> and <code>tuple<char(&)[10]></code> are valid instantiations.
|
||||
|
||||
|
||||
<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 < <i>k</i> <= <i>n</i>.
|
||||
For example:
|
||||
<pre><code>tuple<int, double>()
|
||||
tuple<int, double>(1)
|
||||
tuple<int, double>(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<X,X,X>() // error: no default constructor for X
|
||||
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
|
||||
</code></pre>
|
||||
|
||||
In particular, reference types do not have a default initialization:
|
||||
|
||||
<pre><code>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
|
||||
</code></pre>
|
||||
|
||||
<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<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:
|
||||
<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>
|
||||
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<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&>
|
||||
</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("Donald", "Daisy");
|
||||
</code></pre>
|
||||
|
||||
This creates an object of type <code>tuple<const char (&)[5], 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.
|
||||
|
||||
<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(&f); // tuple<void (*)(int)>
|
||||
...
|
||||
tuple<tuple<void (&)(int)> > 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<N>()
|
||||
</code></pre>
|
||||
or
|
||||
<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.
|
||||
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<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
|
||||
</code></pre>
|
||||
|
||||
<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&); }
|
||||
struct D { operator C() const; }
|
||||
tuple<char, B*, B, D> t;
|
||||
...
|
||||
tuple<int, A*, C, C> 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<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.
|
||||
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><, >, <=</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<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..."
|
||||
</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<int&, char&, double&></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 << i << " " << c << " " << 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:
|
||||
|
||||
<pre><code>char c;
|
||||
tie(ignore, c) = std::make_pair(1, 'a');
|
||||
</code></pre>
|
||||
|
||||
<h2><a name = "streaming">Streaming</a></h2>
|
||||
|
||||
<p>
|
||||
The global <code>operator<<</code> has been overloaded for <code>std::ostream</code> such that tuples are
|
||||
output by recursively calling <code>operator<<</code> for each element.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Analogously, the global <code>operator>></code> has been overloaded to extract tuples from <code>std::istream</code> by recursively calling <code>operator>></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<float, int, std::string> a(1.0f, 2, std::string("Howdy folks!");
|
||||
|
||||
cout << 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>
|
||||
|
||||
For example:
|
||||
<code><pre>cout << set_open('[') << set_close(']') << set_delimiter(',') << 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>></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<int, int, int> i;
|
||||
tuple<int, int> j;
|
||||
|
||||
cin >> i;
|
||||
cin >> set_open('[') >> set_close(']') >> set_delimiter(':');
|
||||
cin >> 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>
|
||||
|
||||
Tuples are efficient. All functions are small inlined one-liners and a decent compiler will eliminate any extra cost.
|
||||
Particularly, 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& 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();
|
||||
</code></pre>
|
||||
|
||||
and this code:
|
||||
|
||||
<pre><code>tuple<A, B, C> t(A(), B(), C());
|
||||
t.get<0>(); t.get<1>(); t.get<2>();
|
||||
</code></pre>
|
||||
|
||||
<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&, double&);
|
||||
tuple<int, double> 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, Jens Maurer for their help and suggestions.
|
||||
The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes and David Abrahams 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ä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ä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ärvi J.:<i>Tuple Types and Multiple Return Values</i>, C/C++ Users Journal, August 2001.
|
||||
</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Last modified 2001-08-10</p>
|
||||
|
||||
<p>© Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko Jä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>
|
||||
|
||||
|
||||
|
||||
|
||||
@ -36,15 +36,14 @@
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
// -- null_type --------------------------------------------------------
|
||||
struct null_type {};
|
||||
|
||||
// a helper function to provide a const null_type type temporary
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
inline const null_type cnull_type() { return null_type(); }
|
||||
} // end tuples
|
||||
} // end detail
|
||||
|
||||
// - cons forward declaration -----------------------------------------------
|
||||
@ -60,12 +59,11 @@ template <
|
||||
class tuple;
|
||||
|
||||
// tuple_length forward declaration
|
||||
template<class T> struct tuple_length;
|
||||
template<class T> struct length;
|
||||
|
||||
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// -- generate error template, referencing to non-existing members of this
|
||||
// template is used to produce compilation errors intentionally
|
||||
@ -108,24 +106,24 @@ struct default_arg<T&> {
|
||||
};
|
||||
|
||||
// - cons getters --------------------------------------------------------
|
||||
// called: element<N>::get<RETURN_TYPE>(aTuple)
|
||||
// called: get_class<N>::get<RETURN_TYPE>(aTuple)
|
||||
|
||||
template< int N >
|
||||
struct element {
|
||||
struct get_class {
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
return element<N-1>::template get<RET>(t.tail);
|
||||
return get_class<N-1>::template get<RET>(t.tail);
|
||||
}
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(cons<HT, TT>& t)
|
||||
{
|
||||
return element<N-1>::template get<RET>(t.tail);
|
||||
return get_class<N-1>::template get<RET>(t.tail);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct element<0> {
|
||||
struct get_class<0> {
|
||||
template<class RET, class HT, class TT>
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
@ -138,25 +136,24 @@ struct element<0> {
|
||||
}
|
||||
};
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
// -cons type accessors ----------------------------------------
|
||||
// typename tuple_element<N,T>::type gets the type of the
|
||||
// typename tuples::element<N,T>::type gets the type of the
|
||||
// Nth element ot T, first element is at index 0
|
||||
// -------------------------------------------------------
|
||||
|
||||
template<int N, class T>
|
||||
struct tuple_element
|
||||
struct element
|
||||
{
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef typename tuple_element<N-1, Next>::type type;
|
||||
typedef typename element<N-1, Next>::type type;
|
||||
};
|
||||
template<class T>
|
||||
struct tuple_element<0,T>
|
||||
struct element<0,T>
|
||||
{
|
||||
typedef typename T::head_type type;
|
||||
};
|
||||
@ -170,7 +167,7 @@ struct tuple_element<0,T>
|
||||
// (Joel de Guzman's suggestion). Rationale: get functions are part of the
|
||||
// interface, so should the way to express their return types be.
|
||||
|
||||
template <class T> struct tuple_access_traits {
|
||||
template <class T> struct access_traits {
|
||||
typedef const T& const_type;
|
||||
typedef T& non_const_type;
|
||||
|
||||
@ -182,7 +179,7 @@ template <class T> struct tuple_access_traits {
|
||||
// be non-volatile and const. 8.5.3. (5)
|
||||
};
|
||||
|
||||
template <class T> struct tuple_access_traits<T&> {
|
||||
template <class T> struct access_traits<T&> {
|
||||
|
||||
typedef T& const_type;
|
||||
typedef T& non_const_type;
|
||||
@ -194,14 +191,14 @@ template <class T> struct tuple_access_traits<T&> {
|
||||
// get function for non-const cons-lists, returns a reference to the element
|
||||
|
||||
template<int N, class HT, class TT>
|
||||
inline typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type
|
||||
get(cons<HT, TT>& c) {
|
||||
return detail::tuples::element<N>::template
|
||||
return detail::get_class<N>::template
|
||||
get<
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type>(c);
|
||||
}
|
||||
|
||||
@ -209,14 +206,14 @@ get(cons<HT, TT>& c) {
|
||||
// the element. If the element is a reference, returns the reference
|
||||
// as such (that is, can return a non-const reference)
|
||||
template<int N, class HT, class TT>
|
||||
inline typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type
|
||||
get(const cons<HT, TT>& c) {
|
||||
return detail::tuples::element<N>::template
|
||||
return detail::get_class<N>::template
|
||||
get<
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type>(c);
|
||||
}
|
||||
|
||||
@ -234,25 +231,25 @@ struct cons {
|
||||
head_type head;
|
||||
tail_type tail;
|
||||
|
||||
typename tuple_access_traits<head_type>::non_const_type
|
||||
typename access_traits<head_type>::non_const_type
|
||||
get_head() { return head; }
|
||||
|
||||
typename tuple_access_traits<tail_type>::non_const_type
|
||||
typename access_traits<tail_type>::non_const_type
|
||||
get_tail() { return tail; }
|
||||
|
||||
typename tuple_access_traits<head_type>::const_type
|
||||
typename access_traits<head_type>::const_type
|
||||
get_head() const { return head; }
|
||||
|
||||
typename tuple_access_traits<tail_type>::const_type
|
||||
typename access_traits<tail_type>::const_type
|
||||
get_tail() const { return tail; }
|
||||
|
||||
cons() : head(detail::tuples::default_arg<HT>::f()), tail() {}
|
||||
cons() : head(detail::default_arg<HT>::f()), tail() {}
|
||||
// the argument for head is not strictly needed, but it prevents
|
||||
// array type elements. This is good, since array type elements
|
||||
// cannot be supported properly in any case (no assignment,
|
||||
// copy works only if the tails are exactly the same type, ...)
|
||||
|
||||
cons(typename tuple_access_traits<head_type>::parameter_type h,
|
||||
cons(typename access_traits<head_type>::parameter_type h,
|
||||
const tail_type& t)
|
||||
: head (h), tail(t) {}
|
||||
|
||||
@ -261,7 +258,7 @@ struct cons {
|
||||
cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
|
||||
T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
|
||||
: head (t1),
|
||||
tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::tuples::cnull_type())
|
||||
tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull_type())
|
||||
{}
|
||||
|
||||
template <class HT2, class TT2>
|
||||
@ -280,22 +277,22 @@ struct cons {
|
||||
|
||||
template <class T1, class T2>
|
||||
cons& operator=( const std::pair<T1, T2>& u ) {
|
||||
BOOST_STATIC_ASSERT(tuple_length<cons>::value == 2); // check length = 2
|
||||
BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
|
||||
head = u.first; tail.head = u.second; return *this;
|
||||
}
|
||||
|
||||
// get member functions (non-const and const)
|
||||
template <int N>
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type
|
||||
get() {
|
||||
return boost::get<N>(*this); // delegate to non-member get
|
||||
}
|
||||
|
||||
template <int N>
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons<HT, TT> >::type
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type
|
||||
get() const {
|
||||
return boost::get<N>(*this); // delegate to non-member get
|
||||
@ -310,19 +307,19 @@ struct cons<HT, null_type> {
|
||||
|
||||
head_type head;
|
||||
|
||||
typename tuple_access_traits<head_type>::non_const_type
|
||||
typename access_traits<head_type>::non_const_type
|
||||
get_head() { return head; }
|
||||
|
||||
null_type get_tail() { return null_type(); }
|
||||
|
||||
typename tuple_access_traits<head_type>::const_type
|
||||
typename access_traits<head_type>::const_type
|
||||
get_head() const { return head; }
|
||||
|
||||
const null_type get_tail() const { return null_type(); }
|
||||
|
||||
cons() : head(detail::tuples::default_arg<HT>::f()) {}
|
||||
cons() : head(detail::default_arg<HT>::f()) {}
|
||||
|
||||
cons(typename tuple_access_traits<head_type>::parameter_type h,
|
||||
cons(typename access_traits<head_type>::parameter_type h,
|
||||
const null_type& = null_type())
|
||||
: head (h) {}
|
||||
|
||||
@ -344,16 +341,16 @@ struct cons<HT, null_type> {
|
||||
cons& operator=(const cons& u) { head = u.head; return *this; }
|
||||
|
||||
template <int N>
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons>::type
|
||||
typename access_traits<
|
||||
typename element<N, cons>::type
|
||||
>::non_const_type
|
||||
get() {
|
||||
return boost::get<N>(*this);
|
||||
}
|
||||
|
||||
template <int N>
|
||||
typename tuple_access_traits<
|
||||
typename tuple_element<N, cons>::type
|
||||
typename access_traits<
|
||||
typename element<N, cons>::type
|
||||
>::const_type
|
||||
get() const {
|
||||
return boost::get<N>(*this);
|
||||
@ -364,18 +361,17 @@ struct cons<HT, null_type> {
|
||||
// templates for finding out the length of the tuple -------------------
|
||||
|
||||
template<class T>
|
||||
struct tuple_length {
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + tuple_length<typename T::tail_type>::value);
|
||||
struct length {
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct tuple_length<null_type> {
|
||||
struct length<null_type> {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// Tuple to cons mapper --------------------------------------------------
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
@ -395,7 +391,6 @@ struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type,
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
} // end tuples
|
||||
} // end detail
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
@ -404,37 +399,37 @@ template <class T0, class T1, class T2, class T3, class T4,
|
||||
class T5, class T6, class T7, class T8, class T9>
|
||||
|
||||
class tuple :
|
||||
public detail::tuples::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
{
|
||||
public:
|
||||
typedef typename
|
||||
detail::tuples::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
|
||||
detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
|
||||
typedef typename inherited::head_type head_type;
|
||||
typedef typename inherited::tail_type tail_type;
|
||||
|
||||
|
||||
// tuple_access_traits<T>::parameter_type takes non-reference types as const T&
|
||||
// access_traits<T>::parameter_type takes non-reference types as const T&
|
||||
explicit tuple(
|
||||
typename tuple_access_traits<T0>::parameter_type t0
|
||||
= detail::tuples::default_arg<T0>::f(),
|
||||
typename tuple_access_traits<T1>::parameter_type t1
|
||||
= detail::tuples::default_arg<T1>::f(),
|
||||
typename tuple_access_traits<T2>::parameter_type t2
|
||||
= detail::tuples::default_arg<T2>::f(),
|
||||
typename tuple_access_traits<T3>::parameter_type t3
|
||||
= detail::tuples::default_arg<T3>::f(),
|
||||
typename tuple_access_traits<T4>::parameter_type t4
|
||||
= detail::tuples::default_arg<T4>::f(),
|
||||
typename tuple_access_traits<T5>::parameter_type t5
|
||||
= detail::tuples::default_arg<T5>::f(),
|
||||
typename tuple_access_traits<T6>::parameter_type t6
|
||||
= detail::tuples::default_arg<T6>::f(),
|
||||
typename tuple_access_traits<T7>::parameter_type t7
|
||||
= detail::tuples::default_arg<T7>::f(),
|
||||
typename tuple_access_traits<T8>::parameter_type t8
|
||||
= detail::tuples::default_arg<T8>::f(),
|
||||
typename tuple_access_traits<T9>::parameter_type t9
|
||||
= detail::tuples::default_arg<T9>::f())
|
||||
typename access_traits<T0>::parameter_type t0
|
||||
= detail::default_arg<T0>::f(),
|
||||
typename access_traits<T1>::parameter_type t1
|
||||
= detail::default_arg<T1>::f(),
|
||||
typename access_traits<T2>::parameter_type t2
|
||||
= detail::default_arg<T2>::f(),
|
||||
typename access_traits<T3>::parameter_type t3
|
||||
= detail::default_arg<T3>::f(),
|
||||
typename access_traits<T4>::parameter_type t4
|
||||
= detail::default_arg<T4>::f(),
|
||||
typename access_traits<T5>::parameter_type t5
|
||||
= detail::default_arg<T5>::f(),
|
||||
typename access_traits<T6>::parameter_type t6
|
||||
= detail::default_arg<T6>::f(),
|
||||
typename access_traits<T7>::parameter_type t7
|
||||
= detail::default_arg<T7>::f(),
|
||||
typename access_traits<T8>::parameter_type t8
|
||||
= detail::default_arg<T8>::f(),
|
||||
typename access_traits<T9>::parameter_type t9
|
||||
= detail::default_arg<T9>::f())
|
||||
|
||||
: inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
|
||||
|
||||
@ -449,7 +444,7 @@ public:
|
||||
|
||||
template <class U1, class U2>
|
||||
tuple& operator=(const std::pair<U1, U2>& k) {
|
||||
BOOST_STATIC_ASSERT(tuple_length<tuple>::value == 2);// check_length = 2
|
||||
BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
|
||||
this->head = k.first;
|
||||
this->tail.head = k.second;
|
||||
return *this;
|
||||
@ -469,7 +464,6 @@ public:
|
||||
|
||||
// Swallows any assignment (by Doug Gregor)
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
struct swallow_assign {
|
||||
|
||||
@ -478,12 +472,12 @@ struct swallow_assign {
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
} // namespace tuples
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
namespace {
|
||||
detail::tuples::swallow_assign ignore;
|
||||
detail::swallow_assign ignore;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@ -530,7 +524,7 @@ struct make_tuple_traits {
|
||||
template<class T>
|
||||
struct make_tuple_traits<T&> {
|
||||
typedef typename
|
||||
detail::tuples::generate_error<T&>::
|
||||
detail::generate_error<T&>::
|
||||
do_not_use_with_reference_type error;
|
||||
};
|
||||
|
||||
@ -570,7 +564,6 @@ struct make_tuple_traits<const reference_wrapper<T> >{
|
||||
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
|
||||
// suggestion)
|
||||
@ -594,7 +587,6 @@ struct make_tuple_mapper {
|
||||
typename make_tuple_traits<T9>::type> type;
|
||||
};
|
||||
|
||||
} // end tuples
|
||||
} // end detail
|
||||
|
||||
// -make_tuple function templates -----------------------------------
|
||||
@ -603,85 +595,85 @@ inline tuple<> make_tuple() {
|
||||
}
|
||||
|
||||
template<class T0>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0>::type
|
||||
inline typename detail::make_tuple_mapper<T0>::type
|
||||
make_tuple(const T0& t0) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0>::type(t0);
|
||||
return typename detail::make_tuple_mapper<T0>::type(t0);
|
||||
}
|
||||
|
||||
template<class T0, class T1>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1>::type
|
||||
make_tuple(const T0& t0, const T1& t1) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0, T1>::type(t0, t1);
|
||||
return typename detail::make_tuple_mapper<T0, T1>::type(t0, t1);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2>::type(t0, t1, t2);
|
||||
return typename detail::make_tuple_mapper<T0, T1, T2>::type(t0, t1, t2);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3>::type
|
||||
return typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
|
||||
(t0, t1, t2, t3);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T4& t4) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4>::type
|
||||
return typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
|
||||
(t0, t1, t2, t3, t4);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T4& t4, const T5& t5) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
|
||||
return typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
|
||||
(t0, t1, t2, t3, t4, t5);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T4& t4, const T5& t5, const T6& t6) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper
|
||||
return typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6>::type
|
||||
(t0, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
|
||||
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
|
||||
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
|
||||
return typename boost::detail::tuples::make_tuple_mapper
|
||||
return typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7>::type
|
||||
(t0, t1, t2, t3, t4, t5, t6, t7);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7, class T8>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper
|
||||
inline typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
|
||||
make_tuple(const T0& t0, 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 typename boost::detail::tuples::make_tuple_mapper
|
||||
return typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
|
||||
(t0, t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7, class T8, class T9>
|
||||
inline typename boost::detail::tuples::make_tuple_mapper
|
||||
inline typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
make_tuple(const T0& t0, 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 typename boost::detail::tuples::make_tuple_mapper
|
||||
return typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
@ -753,6 +745,7 @@ tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
|
||||
}
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
|
||||
|
||||
@ -41,6 +41,7 @@
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
// null_type denotes the end of a list built with "cons"
|
||||
struct null_type
|
||||
@ -53,7 +54,7 @@ namespace boost {
|
||||
inline const null_type cnull_type() { return null_type(); }
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// Takes a pointer and routes all assignments to whatever it points to
|
||||
template<typename T>
|
||||
struct assign_to_pointee
|
||||
@ -82,7 +83,6 @@ namespace boost {
|
||||
}
|
||||
};
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace detail
|
||||
|
||||
// cons builds a heterogenous list of types
|
||||
@ -115,6 +115,12 @@ namespace boost {
|
||||
}
|
||||
|
||||
#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)
|
||||
@ -133,7 +139,7 @@ namespace boost {
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// 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 }; };
|
||||
@ -170,16 +176,16 @@ namespace boost {
|
||||
>
|
||||
struct map_tuple_to_cons
|
||||
{
|
||||
typedef typename detail::tuples::build_cons<T10, null_type >::RET cons10;
|
||||
typedef typename detail::tuples::build_cons<T9, cons10>::RET cons9;
|
||||
typedef typename detail::tuples::build_cons<T8, cons9>::RET cons8;
|
||||
typedef typename detail::tuples::build_cons<T7, cons8>::RET cons7;
|
||||
typedef typename detail::tuples::build_cons<T6, cons7>::RET cons6;
|
||||
typedef typename detail::tuples::build_cons<T5, cons6>::RET cons5;
|
||||
typedef typename detail::tuples::build_cons<T4, cons5>::RET cons4;
|
||||
typedef typename detail::tuples::build_cons<T3, cons4>::RET cons3;
|
||||
typedef typename detail::tuples::build_cons<T2, cons3>::RET cons2;
|
||||
typedef typename detail::tuples::build_cons<T1, cons2>::RET cons1;
|
||||
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
|
||||
@ -207,15 +213,16 @@ namespace boost {
|
||||
typedef typename Tuple::head_type RET;
|
||||
};
|
||||
};
|
||||
} // detail
|
||||
} // tuples
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
// Return the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct tuple_element
|
||||
struct element
|
||||
{
|
||||
private:
|
||||
typedef detail::tuples::_element_type<N> nth_type;
|
||||
typedef detail::_element_type<N> nth_type;
|
||||
|
||||
public:
|
||||
typedef typename nth_type::template inner<Tuple>::RET RET;
|
||||
@ -223,13 +230,13 @@ namespace boost {
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// Return a reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct tuple_element_ref
|
||||
struct element_ref
|
||||
{
|
||||
private:
|
||||
typedef typename tuple_element<N, Tuple>::RET elt_type;
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
|
||||
public:
|
||||
typedef typename add_reference<elt_type>::type RET;
|
||||
@ -238,53 +245,56 @@ namespace boost {
|
||||
|
||||
// Return a const reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct tuple_element_const_ref
|
||||
struct element_const_ref
|
||||
{
|
||||
private:
|
||||
typedef typename tuple_element<N, Tuple>::RET elt_type;
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
|
||||
public:
|
||||
typedef typename add_reference<const elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Get length of this tuple
|
||||
template<typename Tuple>
|
||||
struct tuple_length
|
||||
struct length
|
||||
{
|
||||
enum { value = 1 + tuple_length<typename Tuple::tail_type>::value };
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct tuple_length<null_type>
|
||||
struct length<null_type>
|
||||
{
|
||||
enum { value = 0 };
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Reference the Nth element in a tuple and retrieve it with "get"
|
||||
template<int N>
|
||||
struct element
|
||||
struct get_class
|
||||
{
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename detail::tuples::tuple_element_ref<N, cons<Head, Tail> >::RET
|
||||
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
||||
get(cons<Head, Tail>& t)
|
||||
{
|
||||
return element<N-1>::get(t.tail);
|
||||
return get_class<N-1>::get(t.tail);
|
||||
}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename detail::tuples::tuple_element_const_ref<N, cons<Head, Tail> >::RET
|
||||
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
||||
get(const cons<Head, Tail>& t)
|
||||
{
|
||||
return element<N-1>::get(t.tail);
|
||||
return get_class<N-1>::get(t.tail);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct element<0>
|
||||
struct get_class<0>
|
||||
{
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
@ -303,6 +313,8 @@ namespace boost {
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// tuple class
|
||||
template<
|
||||
typename T1,
|
||||
@ -317,10 +329,10 @@ namespace boost {
|
||||
typename T10 = null_type
|
||||
>
|
||||
class tuple :
|
||||
public detail::tuples::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
||||
public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
||||
{
|
||||
private:
|
||||
typedef detail::tuples::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
|
||||
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;
|
||||
@ -374,22 +386,23 @@ namespace boost {
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
template<int N> struct workaround_holder {};
|
||||
}}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename detail::tuples::tuple_element_ref<N, cons<Head, Tail> >::RET
|
||||
get(cons<Head, Tail>& t, detail::tuples::workaround_holder<N>* = 0)
|
||||
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
||||
get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return element<N>::get(t);
|
||||
return detail::get_class<N>::get(t);
|
||||
}
|
||||
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename detail::tuples::tuple_element_const_ref<N, cons<Head, Tail> >::RET
|
||||
get(const cons<Head, Tail>& t, detail::tuples::workaround_holder<N>* = 0)
|
||||
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
||||
get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return element<N>::get(t);
|
||||
return detail::get_class<N>::get(t);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
@ -485,185 +498,186 @@ namespace boost {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1> >
|
||||
tuple<detail::assign_to_pointee<T1> >
|
||||
tie(T1& t1)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1));
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2> >
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2> >
|
||||
tie(T1& t1, T2& t2)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T6>(&t5),
|
||||
detail::tuples::assign_to_pointee<T5>(&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<T6>(&t5),
|
||||
detail::assign_to_pointee<T5>(&t6));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::assign_to_pointee<T8> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::assign_to_pointee<T8>,
|
||||
detail::tuples::assign_to_pointee<T9> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::assign_to_pointee<T8>(&t8),
|
||||
detail::tuples::assign_to_pointee<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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::assign_to_pointee<T8>,
|
||||
detail::tuples::assign_to_pointee<T9>,
|
||||
detail::tuples::assign_to_pointee<T10> >
|
||||
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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::assign_to_pointee<T8>(&t8),
|
||||
detail::tuples::assign_to_pointee<T9>(&t9),
|
||||
detail::tuples::assign_to_pointee<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::tuples::swallow_assign ignore;
|
||||
detail::swallow_assign ignore;
|
||||
}
|
||||
|
||||
} // namespace tuples
|
||||
} // namespace boost
|
||||
#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
|
||||
@ -32,5 +32,14 @@
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
namespace boost {
|
||||
|
||||
using tuples::tuple;
|
||||
using tuples::make_tuple;
|
||||
using tuples::tie;
|
||||
using tuples::get;
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_TUPLE_HPP
|
||||
|
||||
@ -38,6 +38,7 @@
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
inline bool operator==(const null_type&, const null_type&) { return true; }
|
||||
inline bool operator>=(const null_type&, const null_type&) { return true; }
|
||||
@ -48,7 +49,6 @@ inline bool operator>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
// 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).
|
||||
@ -107,7 +107,6 @@ inline bool gte(const T1& lhs, const T2& rhs) {
|
||||
template<>
|
||||
inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
@ -116,10 +115,10 @@ inline bool gte<null_type,null_type>(const null_type&, const null_type&) { retur
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::eq(lhs, rhs);
|
||||
return detail::eq(lhs, rhs);
|
||||
}
|
||||
|
||||
// not equal -----
|
||||
@ -128,52 +127,53 @@ template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::neq(lhs, rhs);
|
||||
return detail::neq(lhs, rhs);
|
||||
}
|
||||
|
||||
// <
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::lt(lhs, rhs);
|
||||
return detail::lt(lhs, rhs);
|
||||
}
|
||||
|
||||
// >
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::gt(lhs, rhs);
|
||||
return detail::gt(lhs, rhs);
|
||||
}
|
||||
|
||||
// <=
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::lte(lhs, rhs);
|
||||
return detail::lte(lhs, rhs);
|
||||
}
|
||||
|
||||
// >=
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple_lengths are equal
|
||||
BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::tuples::gte(lhs, rhs);
|
||||
return detail::gte(lhs, rhs);
|
||||
}
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
|
||||
|
||||
@ -39,9 +39,9 @@
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
class format_info {
|
||||
public:
|
||||
@ -106,47 +106,46 @@ public:
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
};
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
template<class CharType>
|
||||
class tuple_manipulator {
|
||||
const format_info::manipulator_type mt;
|
||||
const detail::format_info::manipulator_type mt;
|
||||
CharType f_c;
|
||||
public:
|
||||
explicit tuple_manipulator(format_info::manipulator_type m, const char c = 0)
|
||||
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 {
|
||||
format_info::set_manipulator(io, mt, f_c);
|
||||
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 {
|
||||
format_info::set_manipulator(io, mt, f_c);
|
||||
detail::format_info::set_manipulator(io, mt, f_c);
|
||||
}
|
||||
#else
|
||||
template<class CharTrait>
|
||||
void set(std::basic_ios<CharType, CharTrait> &io) const {
|
||||
format_info::set_manipulator(io, mt, f_c);
|
||||
detail::format_info::set_manipulator(io, mt, f_c);
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
};
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
inline std::ostream&
|
||||
operator<<(std::ostream& o, const detail::tuples::tuple_manipulator<char>& m) {
|
||||
operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
|
||||
m.set(o);
|
||||
return o;
|
||||
}
|
||||
|
||||
inline std::istream&
|
||||
operator>>(std::istream& i, const detail::tuples::tuple_manipulator<char>& m) {
|
||||
operator>>(std::istream& i, const tuple_manipulator<char>& m) {
|
||||
m.set(i);
|
||||
return i;
|
||||
}
|
||||
@ -155,14 +154,14 @@ operator>>(std::istream& i, const detail::tuples::tuple_manipulator<char>& m) {
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
operator<<(std::basic_ostream<CharType, CharTrait>& o, const detail::tuples::tuple_manipulator<CharType>& m) {
|
||||
operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
|
||||
m.set(o);
|
||||
return o;
|
||||
}
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
operator>>(std::basic_istream<CharType, CharTrait>& i, const detail::tuples::tuple_manipulator<CharType>& m) {
|
||||
operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
|
||||
m.set(i);
|
||||
return i;
|
||||
}
|
||||
@ -170,18 +169,18 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const detail::tuples::tup
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
template<class CharType>
|
||||
inline detail::tuples::tuple_manipulator<CharType> set_open(const CharType c) {
|
||||
return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::open, c);
|
||||
inline tuple_manipulator<CharType> set_open(const CharType c) {
|
||||
return tuple_manipulator<CharType>(detail::format_info::open, c);
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
inline detail::tuples::tuple_manipulator<CharType> set_close(const CharType c) {
|
||||
return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::close, c);
|
||||
inline tuple_manipulator<CharType> set_close(const CharType c) {
|
||||
return tuple_manipulator<CharType>(detail::format_info::close, c);
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
inline detail::tuples::tuple_manipulator<CharType> set_delimiter(const CharType c) {
|
||||
return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::delimiter, c);
|
||||
inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
|
||||
return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
|
||||
}
|
||||
|
||||
|
||||
@ -194,7 +193,6 @@ inline detail::tuples::tuple_manipulator<CharType> set_delimiter(const CharType
|
||||
// set_open, set_close and set_delimiter
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
// Note: The order of the print functions is critical
|
||||
// to let a conforming compiler find and select the correct one.
|
||||
@ -219,7 +217,7 @@ print(std::ostream& o, const cons<T1, T2>& t) {
|
||||
o << t.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuple_length<T2>::value == 0)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return o;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
o << d;
|
||||
@ -256,7 +254,7 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
|
||||
o << t.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuple_length<T2>::value == 0)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return o;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
o << d;
|
||||
@ -266,7 +264,6 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
|
||||
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
} // namespace tuples
|
||||
} // namespace detail
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
@ -275,13 +272,13 @@ inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
|
||||
if (!o.good() ) return o;
|
||||
|
||||
const char l =
|
||||
detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open);
|
||||
detail::format_info::get_manipulator(o, detail::format_info::open);
|
||||
const char r =
|
||||
detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close);
|
||||
detail::format_info::get_manipulator(o, detail::format_info::close);
|
||||
|
||||
o << l;
|
||||
|
||||
detail::tuples::print(o, t);
|
||||
detail::print(o, t);
|
||||
|
||||
o << r;
|
||||
|
||||
@ -297,13 +294,13 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
|
||||
if (!o.good() ) return o;
|
||||
|
||||
const CharType l =
|
||||
detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open);
|
||||
detail::format_info::get_manipulator(o, detail::format_info::open);
|
||||
const CharType r =
|
||||
detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close);
|
||||
detail::format_info::get_manipulator(o, detail::format_info::close);
|
||||
|
||||
o << l;
|
||||
|
||||
detail::tuples::print(o, t);
|
||||
detail::print(o, t);
|
||||
|
||||
o << r;
|
||||
|
||||
@ -316,7 +313,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
|
||||
// input stream operators
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
|
||||
@ -364,7 +360,7 @@ read(std::istream &is, cons<T1, T2>& t1) {
|
||||
is >> t1.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuple_length<T2>::value == 0)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return is;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
@ -373,7 +369,6 @@ read(std::istream &is, cons<T1, T2>& t1) {
|
||||
return read(is, t1.tail);
|
||||
}
|
||||
|
||||
} // end namespace tuples
|
||||
} // end namespace detail
|
||||
|
||||
inline std::istream&
|
||||
@ -381,8 +376,8 @@ operator>>(std::istream &is, null_type&) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
@ -394,11 +389,11 @@ operator>>(std::istream& is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
|
||||
detail::tuples::read(is, t1);
|
||||
detail::read(is, t1);
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
@ -452,7 +447,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
|
||||
is >> t1.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuple_length<T2>::value == 0)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return is;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
@ -461,7 +456,6 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
|
||||
return read(is, t1.tail);
|
||||
}
|
||||
|
||||
} // end namespace tuples
|
||||
} // end namespace detail
|
||||
|
||||
|
||||
@ -471,8 +465,8 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
@ -483,17 +477,18 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
|
||||
detail::tuples::read(is, t1);
|
||||
detail::read(is, t1);
|
||||
|
||||
detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
|
||||
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
|
||||
|
||||
@ -22,12 +22,13 @@
|
||||
#include "boost/tuple/tuple_io.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
namespace detail {
|
||||
|
||||
const int
|
||||
format_info::stream_index[number_of_manipulators]
|
||||
= { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
|
||||
|
||||
} // namespace tuples
|
||||
} // namespace detail
|
||||
} // namespace tuples
|
||||
} // namespace boost
|
||||
|
||||
@ -1,5 +1,8 @@
|
||||
// tuple_test_bench.cpp --------------------------------
|
||||
//
|
||||
// another_test_bench.cpp --------------------------------
|
||||
|
||||
// This file has various tests to see that things that shouldn't
|
||||
// compile, don't compile.
|
||||
|
||||
// Defining any of E1 to E5 or E7 to E11 opens some illegal code that
|
||||
// should cause the compliation to fail.
|
||||
|
||||
@ -8,156 +11,148 @@
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
#include "boost/tuple/tuple_comparison.hpp"
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::tuples;
|
||||
|
||||
class foo
|
||||
{
|
||||
|
||||
template<class T> void dummy(const T&) {}
|
||||
|
||||
class A {}; class B {}; class C {};
|
||||
|
||||
// A non-copyable class
|
||||
class no_copy {
|
||||
no_copy(const no_copy&) {}
|
||||
public:
|
||||
explicit foo(int v) : val(v) {}
|
||||
|
||||
bool operator==(const foo& other) const
|
||||
{
|
||||
return val == other.val;
|
||||
}
|
||||
|
||||
private:
|
||||
foo() {}
|
||||
int val;
|
||||
no_copy() {};
|
||||
};
|
||||
|
||||
void
|
||||
construction_test()
|
||||
{
|
||||
tuple<int> t1;
|
||||
BOOST_TEST(get<0>(t1) == int());
|
||||
|
||||
tuple<float> t2(5.5f);
|
||||
BOOST_TEST(get<0>(t2) == 5.5f);
|
||||
no_copy y;
|
||||
|
||||
tuple<foo> t3(foo(12));
|
||||
BOOST_TEST(get<0>(t3) == foo(12));
|
||||
#ifdef E1
|
||||
tuple<no_copy> v1; // should faild
|
||||
#endif
|
||||
|
||||
tuple<double> t4(t2);
|
||||
BOOST_TEST(get<0>(t4) == 5.5);
|
||||
|
||||
tuple<int, float> t5;
|
||||
BOOST_TEST(get<0>(t5) == int());
|
||||
BOOST_TEST(get<1>(t5) == float());
|
||||
#ifdef E2
|
||||
char cs[10];
|
||||
tuple<char[10]> v3; // should fail, arrays must be stored as references
|
||||
#endif
|
||||
|
||||
tuple<int, float> t6(12, 5.5f);
|
||||
BOOST_TEST(get<0>(t6) == 12);
|
||||
BOOST_TEST(get<1>(t6) == 5.5f);
|
||||
// a class without a public default constructor
|
||||
class no_def_constructor {
|
||||
no_def_constructor() {}
|
||||
public:
|
||||
no_def_constructor(std::string) {} // can be constructed with a string
|
||||
};
|
||||
|
||||
tuple<long, double> t7(t6);
|
||||
BOOST_TEST(get<0>(t7) == 12);
|
||||
BOOST_TEST(get<1>(t7) == 5.5f);
|
||||
void foo1() {
|
||||
|
||||
#ifdef E3
|
||||
dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>());
|
||||
// should fail
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
copy_test()
|
||||
{
|
||||
tuple<int, float> t1(4, 12.5f);
|
||||
tuple<int, float> t2(5, 2.2f);
|
||||
t2 = t1;
|
||||
BOOST_TEST(get<0>(t1) == get<0>(t2));
|
||||
BOOST_TEST(get<1>(t1) == get<1>(t2));
|
||||
void foo2() {
|
||||
// testing default values
|
||||
#ifdef E4
|
||||
dummy(tuple<double&>()); // should fail, not defaults for references
|
||||
dummy(tuple<const double&>()); // likewise
|
||||
#endif
|
||||
|
||||
tuple<long, double> t3(2, 3.3);
|
||||
t3 = t1;
|
||||
BOOST_TEST((double)get<0>(t1) == get<0>(t3));
|
||||
BOOST_TEST((double)get<1>(t1) == get<1>(t3));
|
||||
}
|
||||
|
||||
void
|
||||
mutate_test()
|
||||
{
|
||||
tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
|
||||
get<0>(t1) = 6;
|
||||
get<1>(t1) = 2.2f;
|
||||
get<2>(t1) = false;
|
||||
get<3>(t1) = foo(5);
|
||||
|
||||
BOOST_TEST(get<0>(t1) == 6);
|
||||
BOOST_TEST(get<1>(t1) == 2.2f);
|
||||
BOOST_TEST(get<2>(t1) == false);
|
||||
BOOST_TEST(get<3>(t1) == foo(5));
|
||||
}
|
||||
|
||||
void
|
||||
make_tuple_test()
|
||||
{
|
||||
tuple<int, float> t1 = make_tuple(5, 2.25f);
|
||||
BOOST_TEST(get<0>(t1) == 5);
|
||||
BOOST_TEST(get<1>(t1) == 2.25f);
|
||||
|
||||
tuple<int, double> t2;
|
||||
t2 = make_tuple((short int)2, 2.25);
|
||||
BOOST_TEST(get<0>(t2) == 2);
|
||||
BOOST_TEST(get<1>(t2) == 2.25);
|
||||
}
|
||||
|
||||
void
|
||||
tie_test()
|
||||
{
|
||||
int a;
|
||||
float b;
|
||||
foo c(5);
|
||||
|
||||
tie(a, b, c) = make_tuple(2, 5.5f, foo(3));
|
||||
BOOST_TEST(a == 2);
|
||||
BOOST_TEST(b == 5.5f);
|
||||
BOOST_TEST(c == foo(3));
|
||||
|
||||
tie(a, ignore, c) = make_tuple((short int)5, false, foo(5));
|
||||
BOOST_TEST(a == 5);
|
||||
BOOST_TEST(b == 5.5f);
|
||||
BOOST_TEST(c == foo(5));
|
||||
}
|
||||
|
||||
void
|
||||
equality_test()
|
||||
{
|
||||
tuple<int, float> t1(5, 3.3f);
|
||||
tuple<int, float> t2(5, 3.3f);
|
||||
BOOST_TEST(t1 == t2);
|
||||
|
||||
tuple<int, float> t3(5, 2.2f);
|
||||
tuple<int, float> t4(2, 3.3f);
|
||||
BOOST_TEST(t1 != t3);
|
||||
BOOST_TEST(t1 != t4);
|
||||
}
|
||||
|
||||
void
|
||||
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);
|
||||
double dd = 5;
|
||||
|
||||
#ifdef E5
|
||||
dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
test_main(int, char *[])
|
||||
|
||||
// make_tuple ------------------------------------------
|
||||
|
||||
|
||||
void foo3() {
|
||||
#ifdef E7
|
||||
std::make_pair("Doesn't","Work"); // fails
|
||||
#endif
|
||||
// make_tuple("Does", "Work"); // this should work
|
||||
}
|
||||
|
||||
|
||||
|
||||
// - testing element access
|
||||
|
||||
void foo4()
|
||||
{
|
||||
construction_test();
|
||||
copy_test();
|
||||
mutate_test();
|
||||
make_tuple_test();
|
||||
tie_test();
|
||||
equality_test();
|
||||
ordering_test();
|
||||
#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;
|
||||
|
||||
#ifdef E8
|
||||
get<0>(ct) = 5; // can't assign to const
|
||||
#endif
|
||||
|
||||
#ifdef E9
|
||||
get<4>(t) = A(); // can't assign to const
|
||||
#endif
|
||||
#ifdef E10
|
||||
dummy(get<5>(ct)); // illegal index
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
// testing copy and assignment with implicit conversions between elements
|
||||
// testing tie
|
||||
|
||||
class AA {};
|
||||
class BB : public AA {};
|
||||
struct CC { CC() {} CC(const BB& b) {} };
|
||||
struct DD { operator CC() const { return CC(); }; };
|
||||
|
||||
void foo5() {
|
||||
tuple<char, BB*, BB, DD> t;
|
||||
|
||||
tuple<char, char> aaa;
|
||||
tuple<int, int> bbb(aaa);
|
||||
// tuple<int, AA*, CC, CC> a = t;
|
||||
// a = t;
|
||||
}
|
||||
|
||||
|
||||
// testing tie
|
||||
// testing assignment from std::pair
|
||||
void foo7() {
|
||||
|
||||
tuple<int, int, float> a;
|
||||
#ifdef E11
|
||||
a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
|
||||
#endif
|
||||
|
||||
dummy(a);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// --------------------------------
|
||||
// ----------------------------
|
||||
int test_main(int, char *[]) {
|
||||
|
||||
foo1();
|
||||
foo2();
|
||||
foo3();
|
||||
foo4();
|
||||
foo5();
|
||||
|
||||
foo7();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -34,6 +34,10 @@ typedef istringstream useThisIStringStream;
|
||||
|
||||
int test_main(int argc, char * argv[] ) {
|
||||
|
||||
using boost::tuples::set_close;
|
||||
using boost::tuples::set_open;
|
||||
using boost::tuples::set_delimiter;
|
||||
|
||||
useThisOStringStream os1;
|
||||
|
||||
// Set format [a, b, c] for os1
|
||||
|
||||
@ -1,8 +1,5 @@
|
||||
// tuple_test_bench.cpp --------------------------------
|
||||
|
||||
// Defining any of E1 to E5 or E7 to E11 opens some illegal code that
|
||||
// should cause the compliation to fail.
|
||||
|
||||
#define BOOST_INCLUDE_MAIN // for testing, include rather than link
|
||||
#include <boost/test/test_tools.hpp> // see "Header Implementation Option"
|
||||
|
||||
@ -12,24 +9,63 @@
|
||||
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// helpers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class A {};
|
||||
class B {};
|
||||
class C {};
|
||||
|
||||
// classes with different kinds of conversions
|
||||
class AA {};
|
||||
class BB : public AA {};
|
||||
struct CC { CC() {} CC(const BB& b) {} };
|
||||
struct DD { operator CC() const { return CC(); }; };
|
||||
|
||||
// something to prevent warnings for unused variables
|
||||
template<class T> void dummy(const T&) {}
|
||||
|
||||
class A {}; class B {}; class C {};
|
||||
// no public default constructor
|
||||
class foo {
|
||||
public:
|
||||
explicit foo(int v) : val(v) {}
|
||||
|
||||
bool operator==(const foo& other) const {
|
||||
return val == other.val;
|
||||
}
|
||||
|
||||
private:
|
||||
foo() {}
|
||||
int val;
|
||||
};
|
||||
|
||||
// another class without a public default constructor
|
||||
class no_def_constructor {
|
||||
no_def_constructor() {}
|
||||
public:
|
||||
no_def_constructor(std::string) {}
|
||||
};
|
||||
|
||||
// A non-copyable class
|
||||
class no_copy {
|
||||
no_copy(const no_copy&) {}
|
||||
public:
|
||||
no_copy() {};
|
||||
};
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Testing different element types --------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
typedef int(t)(float);
|
||||
|
||||
// some arbitrary tuple definitions
|
||||
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;
|
||||
@ -43,84 +79,192 @@ typedef tuple<B(A::*)(C&), A&> t7;
|
||||
|
||||
#endif
|
||||
|
||||
// A non-copyable class
|
||||
class no_copy {
|
||||
no_copy(const no_copy&) {}
|
||||
public:
|
||||
no_copy() {};
|
||||
};
|
||||
// -----------------------------------------------------------------------
|
||||
// -tuple construction tests ---------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
no_copy y;
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
no_copy y;
|
||||
tuple<no_copy&> x = tuple<no_copy&>(y); // ok
|
||||
#endif
|
||||
#ifdef E1
|
||||
tuple<no_copy> v1; // should faild
|
||||
#endif
|
||||
|
||||
char cs[10];
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
char cs[10];
|
||||
tuple<char(&)[10]> v2(cs); // ok
|
||||
#endif
|
||||
#ifdef E2
|
||||
tuple<char[10]> v3; // should fail, arrays must be stored as references
|
||||
#endif
|
||||
|
||||
void
|
||||
construction_test()
|
||||
{
|
||||
|
||||
// Note, the get function can be called without the tuples:: qualifier,
|
||||
// as it is lifted to namespace boost with a "using tuples::get" but
|
||||
// MSVC 6.0 just cannot find get without the namespace qualifier
|
||||
|
||||
// -tuple construction tests ------------------------------------
|
||||
tuple<int> t1;
|
||||
BOOST_TEST(tuples::get<0>(t1) == int());
|
||||
|
||||
tuple<float> t2(5.5f);
|
||||
BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f);
|
||||
|
||||
// a class without a public default constructor
|
||||
class no_def_constructor {
|
||||
no_def_constructor() {}
|
||||
public:
|
||||
no_def_constructor(std::string) {} // can be constructed with a string
|
||||
};
|
||||
tuple<foo> t3(foo(12));
|
||||
BOOST_TEST(tuples::get<0>(t3) == foo(12));
|
||||
|
||||
tuple<double> t4(t2);
|
||||
BOOST_TEST(tuples::get<0>(t4) > 5.4 && tuples::get<0>(t4) < 5.6);
|
||||
|
||||
void foo1() {
|
||||
tuple<int, float> t5;
|
||||
BOOST_TEST(tuples::get<0>(t5) == int());
|
||||
BOOST_TEST(tuples::get<1>(t5) == float());
|
||||
|
||||
#ifdef E3
|
||||
dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>());
|
||||
// should fail
|
||||
tuple<int, float> t6(12, 5.5f);
|
||||
BOOST_TEST(tuples::get<0>(t6) == 12);
|
||||
BOOST_TEST(tuples::get<1>(t6) > 5.4f && tuples::get<1>(t6) < 5.6f);
|
||||
|
||||
#endif
|
||||
dummy( tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
|
||||
std::string("Jaba"), // ok, since the default
|
||||
std::string("Daba"), // constructor is not used
|
||||
std::string("Doo")));
|
||||
}
|
||||
tuple<int, float> t7(t6);
|
||||
BOOST_TEST(tuples::get<0>(t7) == 12);
|
||||
BOOST_TEST(tuples::get<1>(t7) > 5.4f && tuples::get<1>(t7) < 5.6f);
|
||||
|
||||
tuple<long, double> t8(t6);
|
||||
BOOST_TEST(tuples::get<0>(t8) == 12);
|
||||
BOOST_TEST(tuples::get<1>(t8) > 5.4f && tuples::get<1>(t8) < 5.6f);
|
||||
|
||||
dummy(
|
||||
tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
|
||||
std::string("Jaba"), // ok, since the default
|
||||
std::string("Daba"), // constructor is not used
|
||||
std::string("Doo")
|
||||
)
|
||||
);
|
||||
|
||||
void foo2() {
|
||||
// testing default values
|
||||
dummy(tuple<int, double>());
|
||||
dummy(tuple<int, double>(1));
|
||||
dummy(tuple<int, double>(1,3.14));
|
||||
|
||||
#ifdef E4
|
||||
dummy(tuple<double&>()); // should fail, not defaults for references
|
||||
dummy(tuple<const double&>()); // likewise
|
||||
#endif
|
||||
|
||||
// dummy(tuple<double&>()); // should fail, not defaults for references
|
||||
// dummy(tuple<const double&>()); // likewise
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
double dd = 5;
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
dummy(tuple<double&>(dd)); // ok
|
||||
|
||||
dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
|
||||
#endif
|
||||
|
||||
#ifdef E5
|
||||
dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
|
||||
#endif
|
||||
// dummy(tuple<double&>(dd+3.14)); // should fail,
|
||||
// // temporary to non-const reference
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing element access ---------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void element_access_test()
|
||||
{
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
dummy(tuple<const double&>(dd+3.14)); // ok, but potentially dangerous
|
||||
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 = tuples::get<0>(t);
|
||||
int j = tuples::get<0>(ct);
|
||||
BOOST_TEST(i == 1 && j == 1);
|
||||
|
||||
tuples::get<0>(t) = 5;
|
||||
BOOST_TEST(t.head == 5);
|
||||
|
||||
// tuples::get<0>(ct) = 5; // can't assign to const
|
||||
|
||||
double e = tuples::get<1>(t);
|
||||
BOOST_TEST(e > 2.69 && e < 2.71);
|
||||
|
||||
tuples::get<1>(t) = 3.14+i;
|
||||
BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
|
||||
|
||||
// tuples::get<4>(t) = A(); // can't assign to const
|
||||
// dummy(tuples::get<5>(ct)); // illegal index
|
||||
|
||||
++tuples::get<0>(t);
|
||||
BOOST_TEST(tuples::get<0>(t) == 6);
|
||||
|
||||
dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
// make_tuple ------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
// - copying tuples -----------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
void
|
||||
copy_test()
|
||||
{
|
||||
tuple<int, char> t1(4, 'a');
|
||||
tuple<int, char> t2(5, 'b');
|
||||
t2 = t1;
|
||||
BOOST_TEST(tuples::get<0>(t1) == tuples::get<0>(t2));
|
||||
BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t2));
|
||||
|
||||
tuple<long, std::string> t3(2, "a");
|
||||
t3 = t1;
|
||||
BOOST_TEST((double)tuples::get<0>(t1) == tuples::get<0>(t3));
|
||||
BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t3)[0]);
|
||||
|
||||
// testing copy and assignment with implicit conversions between elements
|
||||
// testing tie
|
||||
|
||||
tuple<char, BB*, BB, DD> t;
|
||||
tuple<int, AA*, CC, CC> a(t);
|
||||
a = t;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
void
|
||||
mutate_test()
|
||||
{
|
||||
tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
|
||||
tuples::get<0>(t1) = 6;
|
||||
tuples::get<1>(t1) = 2.2f;
|
||||
tuples::get<2>(t1) = false;
|
||||
tuples::get<3>(t1) = foo(5);
|
||||
|
||||
BOOST_TEST(tuples::get<0>(t1) == 6);
|
||||
BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f);
|
||||
BOOST_TEST(tuples::get<2>(t1) == false);
|
||||
BOOST_TEST(tuples::get<3>(t1) == foo(5));
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// make_tuple tests -----------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void
|
||||
make_tuple_test()
|
||||
{
|
||||
tuple<int, char> t1 = make_tuple(5, 'a');
|
||||
BOOST_TEST(tuples::get<0>(t1) == 5);
|
||||
BOOST_TEST(tuples::get<1>(t1) == 'a');
|
||||
|
||||
tuple<int, std::string> t2;
|
||||
t2 = make_tuple((short int)2, std::string("Hi"));
|
||||
BOOST_TEST(tuples::get<0>(t2) == 2);
|
||||
BOOST_TEST(tuples::get<1>(t2) == "Hi");
|
||||
|
||||
|
||||
void foo3() {
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
A a; B b;
|
||||
const A ca = a;
|
||||
@ -131,16 +275,18 @@ void foo2() {
|
||||
make_tuple(ref(ca));
|
||||
#endif
|
||||
|
||||
// the result of make_tuple is assignable:
|
||||
BOOST_TEST(make_tuple(2, 4, 6) ==
|
||||
(make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
make_tuple("Donald", "Daisy"); // should work;
|
||||
#endif
|
||||
#ifdef E7
|
||||
std::make_pair("Doesn't","Work"); // fails
|
||||
#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(foo3);
|
||||
tuple<void(&)()> adf(make_tuple_test);
|
||||
|
||||
dummy(adf); // avoid warning for unused variable
|
||||
#endif
|
||||
@ -148,17 +294,14 @@ void foo2() {
|
||||
// But make_tuple doesn't work
|
||||
// with function references, since it creates a const qualified function type
|
||||
|
||||
// make_tuple(foo3);
|
||||
// make_tuple(make_tuple_test);
|
||||
|
||||
// With function pointers, make_tuple works just fine
|
||||
|
||||
#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
|
||||
make_tuple(&foo3);
|
||||
make_tuple(&make_tuple_test);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
// NOTE:
|
||||
//
|
||||
// wrapping it the function reference with ref helps on gcc 2.95.2.
|
||||
@ -167,103 +310,94 @@ void foo2() {
|
||||
// make_tuple(ref(foo3));
|
||||
|
||||
// It seems that edg can't use implicitly the ref's conversion operator, e.g.:
|
||||
// typedef void (&foo3type) (void);
|
||||
// foo3type foo3ref = static_cast<foo3type>(ref(foo3)); // works fine
|
||||
// foo3type foo3ref = ref(foo3); // error
|
||||
// typedef void (&func_t) (void);
|
||||
// func_t fref = static_cast<func_t>(ref(make_tuple_test)); // works fine
|
||||
// func_t fref = ref(make_tuple_test); // error
|
||||
|
||||
// This is probably not a very common situation, so currently
|
||||
// I don't know how which compiler is right (JJ)
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
// - testing element access
|
||||
|
||||
void foo4()
|
||||
void
|
||||
tie_test()
|
||||
{
|
||||
#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;
|
||||
int a;
|
||||
char b;
|
||||
foo c(5);
|
||||
|
||||
int i = get<0>(t);
|
||||
int j = get<0>(ct);
|
||||
BOOST_TEST(i == 1 && j == 1);
|
||||
|
||||
get<0>(t) = 5;
|
||||
BOOST_TEST(t.head == 5);
|
||||
|
||||
#ifdef E8
|
||||
get<0>(ct) = 5; // can't assign to const
|
||||
#endif
|
||||
tie(a, b, c) = make_tuple(2, 'a', foo(3));
|
||||
BOOST_TEST(a == 2);
|
||||
BOOST_TEST(b == 'a');
|
||||
BOOST_TEST(c == foo(3));
|
||||
|
||||
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);
|
||||
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));
|
||||
|
||||
#ifdef E9
|
||||
get<4>(t) = A(); // can't assign to const
|
||||
#endif
|
||||
#ifdef E10
|
||||
dummy(get<5>(ct)); // illegal index
|
||||
#endif
|
||||
|
||||
++get<0>(t);
|
||||
BOOST_TEST(get<0>(t) == 6);
|
||||
|
||||
dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
|
||||
#endif
|
||||
}
|
||||
|
||||
// testing copy and assignment with implicit conversions between elements
|
||||
// testing tie
|
||||
|
||||
class AA {};
|
||||
class BB : public AA {};
|
||||
struct CC { CC() {} CC(const BB& b) {} };
|
||||
struct DD { operator CC() const { return CC(); }; };
|
||||
|
||||
void foo5() {
|
||||
tuple<char, BB*, BB, DD> t;
|
||||
tuple<int, AA*, CC, CC> a(t);
|
||||
a = t;
|
||||
}
|
||||
|
||||
void foo6() {
|
||||
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.5);
|
||||
}
|
||||
|
||||
// testing tie
|
||||
// testing assignment from std::pair
|
||||
void foo7() {
|
||||
int i, j;
|
||||
tie (i, j) = std::make_pair(1, 2);
|
||||
BOOST_TEST(i == 1 && j == 2);
|
||||
|
||||
tuple<int, int, float> a;
|
||||
tuple<int, int, float> ta;
|
||||
#ifdef E11
|
||||
a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
|
||||
ta = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
|
||||
#endif
|
||||
|
||||
// the result of make_tuple is assignable:
|
||||
BOOST_TEST(make_tuple(2, 4, 6) ==
|
||||
(make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
|
||||
|
||||
dummy(a);
|
||||
dummy(ta);
|
||||
}
|
||||
|
||||
// Testing cons lists
|
||||
void foo8()
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing tuple equality -------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void
|
||||
equality_test()
|
||||
{
|
||||
tuple<int, char> t1(5, 'a');
|
||||
tuple<int, char> t2(5, 'a');
|
||||
BOOST_TEST(t1 == t2);
|
||||
|
||||
tuple<int, char> t3(5, 'b');
|
||||
tuple<int, char> t4(2, 'a');
|
||||
BOOST_TEST(t1 != t3);
|
||||
BOOST_TEST(t1 != t4);
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing tuple comparisons -----------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing cons lists -------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
void cons_test()
|
||||
{
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
using tuples::cons;
|
||||
using tuples::null_type;
|
||||
|
||||
cons<volatile float, null_type> a(1, null_type());
|
||||
cons<const int, cons<volatile float, null_type> > b(2,a);
|
||||
int i = 3;
|
||||
@ -275,27 +409,32 @@ void foo8()
|
||||
#endif
|
||||
}
|
||||
|
||||
// Testing const tuples
|
||||
void foo9()
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing const tuples -----------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
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_TEST(tuples::get<0>(t1) == 5);
|
||||
BOOST_TEST(tuples::get<1>(t1) == 3.3f);
|
||||
}
|
||||
|
||||
// --------------------------------
|
||||
// ----------------------------
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - main ---------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
int test_main(int, char *[]) {
|
||||
|
||||
foo1();
|
||||
foo2();
|
||||
foo3();
|
||||
foo4();
|
||||
foo5();
|
||||
foo6();
|
||||
foo7();
|
||||
foo8();
|
||||
foo9();
|
||||
|
||||
construction_test();
|
||||
element_access_test();
|
||||
copy_test();
|
||||
mutate_test();
|
||||
make_tuple_test();
|
||||
tie_test();
|
||||
equality_test();
|
||||
ordering_test();
|
||||
cons_test();
|
||||
const_tuple_test();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user