forked from boostorg/tuple
Compare commits
50 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 0afd261a71 | |||
| 28ce70832f | |||
| d08c9bfab1 | |||
| 19b8004830 | |||
| 0af5b76442 | |||
| defe1c94d6 | |||
| 76c2151830 | |||
| 2d13a60d05 | |||
| 9c6ef41dfe | |||
| 5686969287 | |||
| a17ce206f2 | |||
| 34690282fe | |||
| bc3d37ec2b | |||
| eea1937afc | |||
| 8820994ffd | |||
| 045d761ab5 | |||
| 63c93b59b4 | |||
| 78572fca7b | |||
| ad29f96e5b | |||
| 9734556efe | |||
| c8e03a518b | |||
| e4b869219b | |||
| eef0e01c8d | |||
| 41d649b08c | |||
| 122bf636f5 | |||
| 359eaeecbf | |||
| 28e34eb757 | |||
| 5ea6623d49 | |||
| d349450992 | |||
| 8b4daa1385 | |||
| 1972959fda | |||
| 496cc84960 | |||
| c1a28e5d81 | |||
| 4d4fe0010f | |||
| 8992af95d1 | |||
| ae40fce7c9 | |||
| 607b65a946 | |||
| 2c213c8295 | |||
| 5b8506c39b | |||
| 22f56bbe58 | |||
| fb8fa3c7b6 | |||
| cc5a2ae388 | |||
| 4cd544f4c1 | |||
| 74a2ab1242 | |||
| 7896766f8f | |||
| 0a33edd21d | |||
| 53c1bb2c20 | |||
| ea8d71487d | |||
| 6a92d10f25 | |||
| 3570bdb6b6 |
@ -4,7 +4,7 @@
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../c++boost.gif"
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
<h1>Tuple Library : design decisions rationale</h1>
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
<title>Tuple library advanced features</title>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../c++boost.gif"
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
</head>
|
||||
@ -20,7 +20,9 @@ Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integra
|
||||
|
||||
<code><pre>element<N, T>::type</pre></code>
|
||||
|
||||
gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
|
||||
gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well.
|
||||
Note that the constness of <code>T</code> does not affect reference type
|
||||
elements.
|
||||
</p>
|
||||
|
||||
<code><pre>length<T>::value</pre></code>
|
||||
@ -99,7 +101,7 @@ For a one-element cons list the tail argument (<code>null_type</code>) can be om
|
||||
<p>
|
||||
The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
|
||||
<ol>
|
||||
<li><code>access_traits<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>access_traits<T>::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
|
||||
<li><code>access_traits<T>::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
|
||||
<li><code>access_traits<T>::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
|
||||
</ol>
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../c++boost.gif"
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
<h1>The Boost Tuple Library</h1>
|
||||
@ -97,7 +97,7 @@ tuple<A*, tuple<const A*, const B&, C>, bool, void*>
|
||||
|
||||
<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 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)
|
||||
@ -202,7 +202,7 @@ Array arguments to <code>make_tuple</code> functions are deduced to reference to
|
||||
<pre><code>make_tuple("Donald", "Daisy");
|
||||
</code></pre>
|
||||
|
||||
This creates an object of type <code>tuple<const char (&)[5], const char (&)[6]></code>
|
||||
This creates an object of type <code>tuple<const char (&)[7], const char (&)[6]></code>
|
||||
(note that the type of a string literal is an array of const characters, not <code>const char*</code>).
|
||||
However, to get <code>make_tuple</code> to create a tuple with an element of a
|
||||
non-const array type one must use the <code>ref</code> wrapper.
|
||||
@ -264,10 +264,10 @@ A tuple can be copy constructed from another tuple, provided that the element ty
|
||||
Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
|
||||
For example:
|
||||
|
||||
<pre><code>class A;
|
||||
<pre><code>class A {};
|
||||
class B : public A {};
|
||||
struct C { C(); C(const B&); }
|
||||
struct D { operator C() const; }
|
||||
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
|
||||
@ -460,8 +460,8 @@ f1(i,d); // #1
|
||||
tie(i,d) = f2(); // #2
|
||||
</code></pre>
|
||||
See
|
||||
[<a href=#publ_1>1</a>,
|
||||
<a href=#publ_2>2</a>]
|
||||
[<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>
|
||||
@ -472,8 +472,8 @@ Depending on the compiler and the tuple length, it may be more than 10 times slo
|
||||
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>]
|
||||
[<a href="#publ_1">1</a>,
|
||||
<a href="#publ_2">2</a>]
|
||||
for details.
|
||||
</p>
|
||||
|
||||
@ -492,7 +492,7 @@ Below is a list of compilers and known problems with each compiler:
|
||||
</table>
|
||||
|
||||
<h2><a name = "thanks">Acknowledgements</a></h2>
|
||||
Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions.
|
||||
Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions.
|
||||
The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
|
||||
library.
|
||||
The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
|
||||
@ -500,12 +500,12 @@ The idea for the tie mechanism came from an old usenet article by Ian McCulloch,
|
||||
|
||||
<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>).
|
||||
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>).
|
||||
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>
|
||||
@ -514,9 +514,9 @@ Järvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Last modified 2001-09-13</p>
|
||||
<p>Last modified 2003-09-07</p>
|
||||
|
||||
<p>© Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko Järvi</a> 2001.
|
||||
<p>© Copyright <a href="http://www.boost.org/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.
|
||||
|
||||
@ -2,37 +2,32 @@
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// Outside help:
|
||||
// This and that, Gary Powell.
|
||||
// Fixed return types for get_head/get_tail
|
||||
// Fixed return types for get_head/get_tail
|
||||
// ( and other bugs ) per suggestion of Jens Maurer
|
||||
// simplified element type accessors + bug fix (Jeremy Siek)
|
||||
// Several changes/additions according to suggestions by Doug Gregor,
|
||||
// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
|
||||
// Several changes/additions according to suggestions by Douglas Gregor,
|
||||
// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
|
||||
// David Abrahams.
|
||||
|
||||
// Revision history:
|
||||
// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
|
||||
// 2002 04 18 Jaakko: tuple element types can be void or plain function
|
||||
// 2002 04 18 Jaakko: tuple element types can be void or plain function
|
||||
// types, as long as no object is created.
|
||||
// Tuple objects can no hold even noncopyable types
|
||||
// such as arrays.
|
||||
// such as arrays.
|
||||
// 2001 10 22 John Maddock
|
||||
// Fixes for Borland C++
|
||||
// 2001 08 30 David Abrahams
|
||||
// Added default constructor for cons<>.
|
||||
// -----------------------------------------------------------------
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_BASIC_HPP
|
||||
#define BOOST_TUPLE_BASIC_HPP
|
||||
@ -42,7 +37,9 @@
|
||||
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
#include "boost/type_traits/function_traits.hpp"
|
||||
|
||||
|
||||
#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
@ -66,16 +63,16 @@ template <class Then, class Else> struct IF<false, Then, Else> {
|
||||
} // end detail
|
||||
|
||||
// - cons forward declaration -----------------------------------------------
|
||||
template <class HT, class TT> struct cons;
|
||||
template <class HT, class TT> struct cons;
|
||||
|
||||
|
||||
// - tuple forward declaration -----------------------------------------------
|
||||
template <
|
||||
class T0 = null_type, class T1 = null_type, class T2 = null_type,
|
||||
class T3 = null_type, class T4 = null_type, class T5 = null_type,
|
||||
class T6 = null_type, class T7 = null_type, class T8 = null_type,
|
||||
class T0 = null_type, class T1 = null_type, class T2 = null_type,
|
||||
class T3 = null_type, class T4 = null_type, class T5 = null_type,
|
||||
class T6 = null_type, class T7 = null_type, class T8 = null_type,
|
||||
class T9 = null_type>
|
||||
class tuple;
|
||||
class tuple;
|
||||
|
||||
// tuple_length forward declaration
|
||||
template<class T> struct length;
|
||||
@ -84,18 +81,7 @@ template<class T> struct length;
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
|
||||
|
||||
template<int N> struct workaround_holder {};
|
||||
|
||||
# define BOOST_TUPLE_DUMMY_PARM , detail::workaround_holder<N>* = 0
|
||||
# define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder<N>* = 0
|
||||
#else
|
||||
# define BOOST_TUPLE_DUMMY_PARM
|
||||
# define BOOST_TUPLE_SINGLE_DUMMY_PARM
|
||||
#endif
|
||||
|
||||
// -- generate error template, referencing to non-existing members of this
|
||||
// -- generate error template, referencing to non-existing members of this
|
||||
// template is used to produce compilation errors intentionally
|
||||
template<class T>
|
||||
class generate_error;
|
||||
@ -108,23 +94,33 @@ struct get_class {
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
return get_class<N-1>::template get<RET>(t.tail);
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
// vacpp 6.0 is not very consistent regarding the member template keyword
|
||||
// Here it generates an error when the template keyword is used.
|
||||
return get_class<N-1>::get<RET>(t.tail);
|
||||
#else
|
||||
return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
|
||||
#endif
|
||||
}
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(cons<HT, TT>& t)
|
||||
{
|
||||
return get_class<N-1>::template get<RET>(t.tail);
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
return get_class<N-1>::get<RET>(t.tail);
|
||||
#else
|
||||
return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct get_class<0> {
|
||||
template<class RET, class HT, class TT>
|
||||
template<class RET, class HT, class TT>
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
template<class RET, class HT, class TT>
|
||||
template<class RET, class HT, class TT>
|
||||
inline static RET get(cons<HT, TT>& t)
|
||||
{
|
||||
return t.head;
|
||||
@ -135,10 +131,12 @@ struct get_class<0> {
|
||||
|
||||
|
||||
// -cons type accessors ----------------------------------------
|
||||
// typename tuples::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
|
||||
// -------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_NO_CV_SPECIALIZATIONS
|
||||
|
||||
template<int N, class T>
|
||||
struct element
|
||||
{
|
||||
@ -153,6 +151,76 @@ struct element<0,T>
|
||||
typedef typename T::head_type type;
|
||||
};
|
||||
|
||||
template<int N, class T>
|
||||
struct element<N, const T>
|
||||
{
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
typedef typename element<N-1, Next>::type unqualified_type;
|
||||
public:
|
||||
#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
|
||||
typedef const unqualified_type type;
|
||||
#else
|
||||
typedef typename boost::add_const<unqualified_type>::type type;
|
||||
#endif
|
||||
|
||||
};
|
||||
template<class T>
|
||||
struct element<0,const T>
|
||||
{
|
||||
#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
|
||||
typedef const typename T::head_type type;
|
||||
#else
|
||||
typedef typename boost::add_const<typename T::head_type>::type type;
|
||||
#endif
|
||||
};
|
||||
|
||||
#else // def BOOST_NO_CV_SPECIALIZATIONS
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N, class T, bool IsConst>
|
||||
struct element_impl
|
||||
{
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef typename element_impl<N-1, Next, IsConst>::type type;
|
||||
};
|
||||
|
||||
template<int N, class T>
|
||||
struct element_impl<N, T, true /* IsConst */>
|
||||
{
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef const typename element_impl<N-1, Next, true>::type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct element_impl<0, T, false /* IsConst */>
|
||||
{
|
||||
typedef typename T::head_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct element_impl<0, T, true /* IsConst */>
|
||||
{
|
||||
typedef const typename T::head_type type;
|
||||
};
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
template<int N, class T>
|
||||
struct element:
|
||||
public detail::element_impl<N, T, ::boost::is_const<T>::value>
|
||||
{
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// -get function templates -----------------------------------------------
|
||||
// Usage: get<N>(aTuple)
|
||||
|
||||
@ -179,8 +247,8 @@ template <class T> struct access_traits<T&> {
|
||||
|
||||
typedef T& const_type;
|
||||
typedef T& non_const_type;
|
||||
|
||||
typedef T& parameter_type;
|
||||
|
||||
typedef T& parameter_type;
|
||||
};
|
||||
|
||||
// get function for non-const cons-lists, returns a reference to the element
|
||||
@ -189,13 +257,19 @@ template<int N, class HT, class TT>
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type
|
||||
get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) {
|
||||
return detail::get_class<N>::template
|
||||
get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600 )
|
||||
return detail::get_class<N>::
|
||||
#else
|
||||
return detail::get_class<N>::BOOST_NESTED_TEMPLATE
|
||||
#endif
|
||||
get<
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type>(c);
|
||||
}
|
||||
>::non_const_type,
|
||||
HT,TT
|
||||
>(c);
|
||||
}
|
||||
|
||||
// get function for const cons-lists, returns a const reference to
|
||||
// the element. If the element is a reference, returns the reference
|
||||
@ -204,13 +278,19 @@ template<int N, class HT, class TT>
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type
|
||||
get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) {
|
||||
return detail::get_class<N>::template
|
||||
get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
return detail::get_class<N>::
|
||||
#else
|
||||
return detail::get_class<N>::BOOST_NESTED_TEMPLATE
|
||||
#endif
|
||||
get<
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type>(c);
|
||||
}
|
||||
>::const_type,
|
||||
HT,TT
|
||||
>(c);
|
||||
}
|
||||
|
||||
// -- the cons template --------------------------------------------------
|
||||
namespace detail {
|
||||
@ -231,7 +311,7 @@ template <class T> struct wrap_non_storeable_type {
|
||||
>::RET type;
|
||||
};
|
||||
template <> struct wrap_non_storeable_type<void> {
|
||||
typedef non_storeable_type<void> type;
|
||||
typedef non_storeable_type<void> type;
|
||||
};
|
||||
|
||||
} // detail
|
||||
@ -242,49 +322,49 @@ struct cons {
|
||||
typedef HT head_type;
|
||||
typedef TT tail_type;
|
||||
|
||||
typedef typename
|
||||
typedef typename
|
||||
detail::wrap_non_storeable_type<head_type>::type stored_head_type;
|
||||
|
||||
stored_head_type head;
|
||||
tail_type tail;
|
||||
|
||||
typename access_traits<stored_head_type>::non_const_type
|
||||
typename access_traits<stored_head_type>::non_const_type
|
||||
get_head() { return head; }
|
||||
|
||||
typename access_traits<tail_type>::non_const_type
|
||||
get_tail() { return tail; }
|
||||
typename access_traits<tail_type>::non_const_type
|
||||
get_tail() { return tail; }
|
||||
|
||||
typename access_traits<stored_head_type>::const_type
|
||||
typename access_traits<stored_head_type>::const_type
|
||||
get_head() const { return head; }
|
||||
|
||||
typename access_traits<tail_type>::const_type
|
||||
get_tail() const { return tail; }
|
||||
|
||||
typename access_traits<tail_type>::const_type
|
||||
get_tail() const { return tail; }
|
||||
|
||||
cons() : head(), 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,
|
||||
// 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 access_traits<stored_head_type>::parameter_type h,
|
||||
const tail_type& t)
|
||||
: head (h), tail(t) {}
|
||||
: head (h), tail(t) {}
|
||||
|
||||
template <class T1, class T2, class T3, class T4, class T5,
|
||||
template <class T1, class T2, class T3, class T4, class T5,
|
||||
class T6, class T7, class T8, class T9, class T10>
|
||||
cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
|
||||
T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
|
||||
: head (t1),
|
||||
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::cnull())
|
||||
{}
|
||||
|
||||
template <class T2, class T3, class T4, class T5,
|
||||
template <class T2, class T3, class T4, class T5,
|
||||
class T6, class T7, class T8, class T9, class T10>
|
||||
cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5,
|
||||
T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
|
||||
: head (),
|
||||
cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
|
||||
T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
|
||||
: head (),
|
||||
tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
|
||||
{}
|
||||
|
||||
@ -293,18 +373,18 @@ struct cons {
|
||||
cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
|
||||
|
||||
template <class HT2, class TT2>
|
||||
cons& operator=( const cons<HT2, TT2>& u ) {
|
||||
head=u.head; tail=u.tail; return *this;
|
||||
cons& operator=( const cons<HT2, TT2>& u ) {
|
||||
head=u.head; tail=u.tail; return *this;
|
||||
}
|
||||
|
||||
// must define assignment operator explicitly, implicit version is
|
||||
// must define assignment operator explicitly, implicit version is
|
||||
// illformed if HT is a reference (12.8. (12))
|
||||
cons& operator=(const cons& u) {
|
||||
head = u.head; tail = u.tail; return *this;
|
||||
cons& operator=(const cons& u) {
|
||||
head = u.head; tail = u.tail; return *this;
|
||||
}
|
||||
|
||||
template <class T1, class T2>
|
||||
cons& operator=( const std::pair<T1, T2>& u ) {
|
||||
cons& operator=( const std::pair<T1, T2>& u ) {
|
||||
BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
|
||||
head = u.first; tail.head = u.second; return *this;
|
||||
}
|
||||
@ -332,64 +412,65 @@ struct cons<HT, null_type> {
|
||||
|
||||
typedef HT head_type;
|
||||
typedef null_type tail_type;
|
||||
typedef cons<HT, null_type> self_type;
|
||||
|
||||
typedef typename
|
||||
typedef typename
|
||||
detail::wrap_non_storeable_type<head_type>::type stored_head_type;
|
||||
stored_head_type head;
|
||||
|
||||
typename access_traits<stored_head_type>::non_const_type
|
||||
get_head() { return head; }
|
||||
|
||||
null_type get_tail() { return null_type(); }
|
||||
|
||||
typename access_traits<stored_head_type>::const_type
|
||||
typename access_traits<stored_head_type>::non_const_type
|
||||
get_head() { return head; }
|
||||
|
||||
null_type get_tail() { return null_type(); }
|
||||
|
||||
typename access_traits<stored_head_type>::const_type
|
||||
get_head() const { return head; }
|
||||
|
||||
const null_type get_tail() const { return null_type(); }
|
||||
|
||||
const null_type get_tail() const { return null_type(); }
|
||||
|
||||
// cons() : head(detail::default_arg<HT>::f()) {}
|
||||
cons() : head() {}
|
||||
|
||||
cons(typename access_traits<stored_head_type>::parameter_type h,
|
||||
const null_type& = null_type())
|
||||
: head (h) {}
|
||||
: head (h) {}
|
||||
|
||||
template<class T1>
|
||||
cons(T1& t1, const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
cons(T1& t1, const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&)
|
||||
: head (t1) {}
|
||||
|
||||
cons(const null_type& t1,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
cons(const null_type&,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&,
|
||||
const null_type&, const null_type&, const null_type&)
|
||||
: head () {}
|
||||
|
||||
template <class HT2>
|
||||
cons( const cons<HT2, null_type>& u ) : head(u.head) {}
|
||||
|
||||
|
||||
template <class HT2>
|
||||
cons& operator=(const cons<HT2, null_type>& u )
|
||||
cons& operator=(const cons<HT2, null_type>& u )
|
||||
{ head = u.head; return *this; }
|
||||
|
||||
// must define assignment operator explicitely, implicit version
|
||||
// must define assignment operator explicitely, implicit version
|
||||
// is illformed if HT is a reference
|
||||
cons& operator=(const cons& u) { head = u.head; return *this; }
|
||||
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, cons>::type
|
||||
typename element<N, self_type>::type
|
||||
>::non_const_type
|
||||
get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
|
||||
get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
return boost::tuples::get<N>(*this);
|
||||
}
|
||||
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, cons>::type
|
||||
typename element<N, self_type>::type
|
||||
>::const_type
|
||||
get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
|
||||
get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
|
||||
return boost::tuples::get<N>(*this);
|
||||
}
|
||||
|
||||
@ -416,12 +497,12 @@ struct length<null_type> {
|
||||
namespace detail {
|
||||
|
||||
// Tuple to cons mapper --------------------------------------------------
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
class T5, class T6, class T7, class T8, class T9>
|
||||
struct map_tuple_to_cons
|
||||
{
|
||||
typedef cons<T0,
|
||||
typename map_tuple_to_cons<T1, T2, T3, T4, T5,
|
||||
typedef cons<T0,
|
||||
typename map_tuple_to_cons<T1, T2, T3, T4, T5,
|
||||
T6, T7, T8, T9, null_type>::type
|
||||
> type;
|
||||
};
|
||||
@ -437,46 +518,46 @@ struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type,
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// -- tuple ------------------------------------------------------
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
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::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
class tuple :
|
||||
public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
{
|
||||
public:
|
||||
typedef typename
|
||||
typedef typename
|
||||
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;
|
||||
typedef typename inherited::tail_type tail_type;
|
||||
|
||||
|
||||
// access_traits<T>::parameter_type takes non-reference types as const T&
|
||||
// access_traits<T>::parameter_type takes non-reference types as const T&
|
||||
tuple() {}
|
||||
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0)
|
||||
: inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
typename access_traits<T1>::parameter_type t1)
|
||||
: inherited(t0, t1, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, t1, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
typename access_traits<T1>::parameter_type t1,
|
||||
typename access_traits<T2>::parameter_type t2)
|
||||
: inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
typename access_traits<T1>::parameter_type t1,
|
||||
typename access_traits<T2>::parameter_type t2,
|
||||
typename access_traits<T3>::parameter_type t3)
|
||||
: inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
@ -484,7 +565,7 @@ public:
|
||||
typename access_traits<T2>::parameter_type t2,
|
||||
typename access_traits<T3>::parameter_type t3,
|
||||
typename access_traits<T4>::parameter_type t4)
|
||||
: inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
@ -493,7 +574,7 @@ public:
|
||||
typename access_traits<T3>::parameter_type t3,
|
||||
typename access_traits<T4>::parameter_type t4,
|
||||
typename access_traits<T5>::parameter_type t5)
|
||||
: inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
|
||||
: inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
@ -503,7 +584,7 @@ public:
|
||||
typename access_traits<T4>::parameter_type t4,
|
||||
typename access_traits<T5>::parameter_type t5,
|
||||
typename access_traits<T6>::parameter_type t6)
|
||||
: inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
|
||||
: inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
|
||||
detail::cnull(), detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
@ -514,7 +595,7 @@ public:
|
||||
typename access_traits<T5>::parameter_type t5,
|
||||
typename access_traits<T6>::parameter_type t6,
|
||||
typename access_traits<T7>::parameter_type t7)
|
||||
: inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
|
||||
: inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
|
||||
detail::cnull()) {}
|
||||
|
||||
tuple(typename access_traits<T0>::parameter_type t0,
|
||||
@ -545,16 +626,16 @@ public:
|
||||
tuple(const cons<U1, U2>& p) : inherited(p) {}
|
||||
|
||||
template <class U1, class U2>
|
||||
tuple& operator=(const cons<U1, U2>& k) {
|
||||
inherited::operator=(k);
|
||||
tuple& operator=(const cons<U1, U2>& k) {
|
||||
inherited::operator=(k);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class U1, class U2>
|
||||
tuple& operator=(const std::pair<U1, U2>& k) {
|
||||
tuple& operator=(const std::pair<U1, U2>& k) {
|
||||
BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
|
||||
this->head = k.first;
|
||||
this->tail.head = k.second;
|
||||
this->tail.head = k.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -562,8 +643,8 @@ public:
|
||||
|
||||
// The empty tuple
|
||||
template <>
|
||||
class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
|
||||
public null_type
|
||||
class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
|
||||
public null_type
|
||||
{
|
||||
public:
|
||||
typedef null_type inherited;
|
||||
@ -574,19 +655,17 @@ public:
|
||||
namespace detail {
|
||||
|
||||
struct swallow_assign {
|
||||
|
||||
|
||||
template<typename T>
|
||||
swallow_assign& operator=(const T&) {
|
||||
swallow_assign const& operator=(const T&) const {
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
namespace {
|
||||
detail::swallow_assign ignore;
|
||||
}
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
detail::swallow_assign const ignore = detail::swallow_assign();
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The call_traits for make_tuple
|
||||
@ -598,7 +677,7 @@ namespace {
|
||||
// from template<class T> foo(T& t) : make_tuple_traits<T>::type
|
||||
|
||||
// Conversions:
|
||||
// T -> T,
|
||||
// T -> T,
|
||||
// references -> compile_time_error
|
||||
// reference_wrapper<T> -> T&
|
||||
// const reference_wrapper<T> -> T&
|
||||
@ -607,19 +686,19 @@ namespace {
|
||||
|
||||
template<class T>
|
||||
struct make_tuple_traits {
|
||||
typedef T type;
|
||||
typedef T type;
|
||||
|
||||
// commented away, see below (JJ)
|
||||
// typedef typename IF<
|
||||
// typedef typename IF<
|
||||
// boost::is_function<T>::value,
|
||||
// T&,
|
||||
// T>::RET type;
|
||||
|
||||
};
|
||||
|
||||
// The is_function test was there originally for plain function types,
|
||||
|
||||
// The is_function test was there originally for plain function types,
|
||||
// which can't be stored as such (we must either store them as references or
|
||||
// pointers). Such a type could be formed if make_tuple was called with a
|
||||
// pointers). Such a type could be formed if make_tuple was called with a
|
||||
// reference to a function.
|
||||
// But this would mean that a const qualified function type was formed in
|
||||
// the make_tuple function and hence make_tuple can't take a function
|
||||
@ -634,17 +713,17 @@ struct make_tuple_traits<T&> {
|
||||
typedef typename
|
||||
detail::generate_error<T&>::
|
||||
do_not_use_with_reference_type error;
|
||||
};
|
||||
};
|
||||
|
||||
// Arrays can't be stored as plain types; convert them to references.
|
||||
// All arrays are converted to const. This is because make_tuple takes its
|
||||
// parameters as const T& and thus the knowledge of the potential
|
||||
// parameters as const T& and thus the knowledge of the potential
|
||||
// non-constness of actual argument is lost.
|
||||
template<class T, int n> struct make_tuple_traits <T[n]> {
|
||||
typedef const T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T, int n>
|
||||
template<class T, int n>
|
||||
struct make_tuple_traits<const T[n]> {
|
||||
typedef const T (&type)[n];
|
||||
};
|
||||
@ -653,17 +732,17 @@ template<class T, int n> struct make_tuple_traits<volatile T[n]> {
|
||||
typedef const volatile T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T, int n>
|
||||
template<class T, int n>
|
||||
struct make_tuple_traits<const volatile T[n]> {
|
||||
typedef const volatile T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T>
|
||||
template<class T>
|
||||
struct make_tuple_traits<reference_wrapper<T> >{
|
||||
typedef T& type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
template<class T>
|
||||
struct make_tuple_traits<const reference_wrapper<T> >{
|
||||
typedef T& type;
|
||||
};
|
||||
@ -676,20 +755,20 @@ namespace detail {
|
||||
// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
|
||||
// suggestion)
|
||||
template <
|
||||
class T0 = null_type, class T1 = null_type, class T2 = null_type,
|
||||
class T3 = null_type, class T4 = null_type, class T5 = null_type,
|
||||
class T6 = null_type, class T7 = null_type, class T8 = null_type,
|
||||
class T0 = null_type, class T1 = null_type, class T2 = null_type,
|
||||
class T3 = null_type, class T4 = null_type, class T5 = null_type,
|
||||
class T6 = null_type, class T7 = null_type, class T8 = null_type,
|
||||
class T9 = null_type
|
||||
>
|
||||
struct make_tuple_mapper {
|
||||
typedef
|
||||
tuple<typename make_tuple_traits<T0>::type,
|
||||
typename make_tuple_traits<T1>::type,
|
||||
typename make_tuple_traits<T2>::type,
|
||||
typename make_tuple_traits<T3>::type,
|
||||
typename make_tuple_traits<T4>::type,
|
||||
typename make_tuple_traits<T5>::type,
|
||||
typename make_tuple_traits<T6>::type,
|
||||
tuple<typename make_tuple_traits<T0>::type,
|
||||
typename make_tuple_traits<T1>::type,
|
||||
typename make_tuple_traits<T2>::type,
|
||||
typename make_tuple_traits<T3>::type,
|
||||
typename make_tuple_traits<T4>::type,
|
||||
typename make_tuple_traits<T5>::type,
|
||||
typename make_tuple_traits<T6>::type,
|
||||
typename make_tuple_traits<T7>::type,
|
||||
typename make_tuple_traits<T8>::type,
|
||||
typename make_tuple_traits<T9>::type> type;
|
||||
@ -699,7 +778,7 @@ struct make_tuple_mapper {
|
||||
|
||||
// -make_tuple function templates -----------------------------------
|
||||
inline tuple<> make_tuple() {
|
||||
return tuple<>();
|
||||
return tuple<>();
|
||||
}
|
||||
|
||||
template<class T0>
|
||||
@ -735,7 +814,7 @@ 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) {
|
||||
typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
|
||||
return t(t0, t1, t2, t3, t4);
|
||||
return t(t0, t1, t2, t3, t4);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5>
|
||||
@ -743,7 +822,7 @@ 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) {
|
||||
typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5);
|
||||
return t(t0, t1, t2, t3, t4, t5);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
|
||||
@ -762,7 +841,7 @@ 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) {
|
||||
typedef typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7);
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
@ -774,7 +853,7 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T8& t8) {
|
||||
typedef typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
@ -786,7 +865,7 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
const T8& t8, const T9& t9) {
|
||||
typedef typename detail::make_tuple_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
|
||||
@ -813,54 +892,52 @@ inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8, class T9>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
T9& t9) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8, class T9, class T10>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
T9& t9, T10& t10) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
|
||||
}
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
#undef BOOST_TUPLE_DUMMY_PARM
|
||||
#undef BOOST_TUPLE_SINGLE_DUMMY_PARM
|
||||
|
||||
#endif // BOOST_TUPLE_BASIC_HPP
|
||||
|
||||
|
||||
@ -1,32 +1,27 @@
|
||||
// - tuple_basic_no_partial_spec.hpp -----------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
|
||||
// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
|
||||
// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
|
||||
|
||||
// Revision History
|
||||
// Revision History
|
||||
// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
|
||||
// 10 02 01 Fixed "null_type" constructors.
|
||||
// Implemented comparison operators globally.
|
||||
// Hide element_type_ref and element_type_const_ref.
|
||||
// (DG).
|
||||
// 09 02 01 Extended to tuples of length 10. Changed comparison for
|
||||
// 09 02 01 Extended to tuples of length 10. Changed comparison for
|
||||
// operator<()
|
||||
// to the same used by std::pair<>, added cnull_type() (GP)
|
||||
// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG)
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
@ -44,20 +39,20 @@ namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
// null_type denotes the end of a list built with "cons"
|
||||
struct null_type
|
||||
struct null_type
|
||||
{
|
||||
null_type() {}
|
||||
null_type(const null_type&, const null_type&) {}
|
||||
};
|
||||
|
||||
|
||||
// a helper function to provide a const null_type type temporary
|
||||
inline const null_type cnull_type() { return null_type(); }
|
||||
|
||||
// forward declaration of tuple
|
||||
template<
|
||||
typename T1 = null_type,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T1 = null_type,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type,
|
||||
typename T5 = null_type,
|
||||
typename T6 = null_type,
|
||||
@ -68,6 +63,10 @@ namespace tuples {
|
||||
>
|
||||
class tuple;
|
||||
|
||||
// forward declaration of cons
|
||||
template<typename Head, typename Tail = null_type>
|
||||
struct cons;
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Takes a pointer and routes all assignments to whatever it points to
|
||||
@ -92,57 +91,125 @@ namespace tuples {
|
||||
struct swallow_assign
|
||||
{
|
||||
template<typename T>
|
||||
swallow_assign& operator=(const T&)
|
||||
swallow_assign const& operator=(const T&) const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
|
||||
|
||||
template <class MyTail>
|
||||
struct init_tail
|
||||
{
|
||||
// Each of vc6 and vc7 seem to require a different formulation
|
||||
// of this return type
|
||||
template <class H, class T>
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
static typename add_reference<typename add_const<T>::type>::type
|
||||
#else
|
||||
static typename add_const_reference<T>::type
|
||||
#endif
|
||||
execute( cons<H,T> const& u, long )
|
||||
{
|
||||
return u.get_tail();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct init_tail<null_type>
|
||||
{
|
||||
template <class H>
|
||||
static null_type execute( cons<H,null_type> const& u, long )
|
||||
{
|
||||
return null_type();
|
||||
}
|
||||
|
||||
template <class U>
|
||||
static null_type execute(U const&, ...)
|
||||
{
|
||||
return null_type();
|
||||
}
|
||||
private:
|
||||
template <class H, class T>
|
||||
void execute( cons<H,T> const&, int);
|
||||
};
|
||||
|
||||
template <class Other>
|
||||
Other const&
|
||||
init_head( Other const& u, ... )
|
||||
{
|
||||
return u;
|
||||
}
|
||||
|
||||
template <class H, class T>
|
||||
typename add_reference<typename add_const<H>::type>::type
|
||||
init_head( cons<H,T> const& u, int )
|
||||
{
|
||||
return u.get_head();
|
||||
}
|
||||
|
||||
inline char**** init_head(null_type const&, int);
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
// cons builds a heterogenous list of types
|
||||
template<typename Head, typename Tail = null_type>
|
||||
template<typename Head, typename Tail>
|
||||
struct cons
|
||||
{
|
||||
typedef cons self_type;
|
||||
typedef Head head_type;
|
||||
typedef Tail tail_type;
|
||||
|
||||
private:
|
||||
typedef typename boost::add_reference<head_type>::type head_ref;
|
||||
typedef typename boost::add_reference<tail_type>::type tail_ref;
|
||||
typedef typename detail::add_const_reference<head_type>::type head_cref;
|
||||
typedef typename detail::add_const_reference<tail_type>::type tail_cref;
|
||||
public:
|
||||
head_type head;
|
||||
tail_type tail;
|
||||
|
||||
typename boost::add_reference<head_type>::type get_head() { return head; }
|
||||
typename boost::add_reference<tail_type>::type get_tail() { return tail; }
|
||||
head_ref get_head() { return head; }
|
||||
tail_ref get_tail() { return tail; }
|
||||
|
||||
head_cref get_head() const { return head; }
|
||||
tail_cref get_tail() const { return tail; }
|
||||
|
||||
cons() : head(), tail() {}
|
||||
|
||||
typename boost::add_reference<const head_type>::type get_head() const { return head; }
|
||||
typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
|
||||
|
||||
#if defined BOOST_MSVC
|
||||
template<typename Tail>
|
||||
explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
const Tail& t) : head(h), tail(t.head, t.tail)
|
||||
{
|
||||
}
|
||||
|
||||
explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
const null_type& t) : head(h), tail(t)
|
||||
{
|
||||
}
|
||||
|
||||
#else
|
||||
template<typename T>
|
||||
explicit cons(const head_type& h, const T& t) :
|
||||
explicit cons(head_cref 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()) :
|
||||
explicit cons(head_cref h = head_type(),
|
||||
tail_cref t = tail_type()) :
|
||||
head(h), tail(t)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class U>
|
||||
cons( const U& u )
|
||||
: head(detail::init_head(u, 0))
|
||||
, tail(detail::init_tail<Tail>::execute(u, 0L))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Other>
|
||||
cons& operator=(const Other& other)
|
||||
@ -152,13 +219,13 @@ namespace tuples {
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Determines if the parameter is null_type
|
||||
template<typename T> struct is_null_type { enum { RET = 0 }; };
|
||||
template<> struct is_null_type<null_type> { enum { RET = 1 }; };
|
||||
|
||||
|
||||
/* Build a cons structure from the given Head and Tail. If both are null_type,
|
||||
return null_type. */
|
||||
template<typename Head, typename Tail>
|
||||
@ -178,15 +245,15 @@ namespace tuples {
|
||||
|
||||
// Map the N elements of a tuple into a cons list
|
||||
template<
|
||||
typename T1,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type,
|
||||
typename T5 = null_type,
|
||||
typename T6 = null_type,
|
||||
typename T7 = null_type,
|
||||
typename T8 = null_type,
|
||||
typename T9 = null_type,
|
||||
typename T1,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type,
|
||||
typename T5 = null_type,
|
||||
typename T6 = null_type,
|
||||
typename T7 = null_type,
|
||||
typename T8 = null_type,
|
||||
typename T9 = null_type,
|
||||
typename T10 = null_type
|
||||
>
|
||||
struct map_tuple_to_cons
|
||||
@ -331,7 +398,7 @@ namespace tuples {
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
|
||||
};
|
||||
|
||||
|
||||
template<> struct length<tuple<> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
@ -389,9 +456,9 @@ namespace tuples {
|
||||
|
||||
// tuple class
|
||||
template<
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3,
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3,
|
||||
typename T4,
|
||||
typename T5,
|
||||
typename T6,
|
||||
@ -400,7 +467,7 @@ namespace tuples {
|
||||
typename T9,
|
||||
typename T10
|
||||
>
|
||||
class tuple :
|
||||
class tuple :
|
||||
public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
||||
{
|
||||
private:
|
||||
@ -416,26 +483,45 @@ namespace tuples {
|
||||
typedef typename mapped_tuple::cons2 cons2;
|
||||
typedef typename mapped_tuple::cons1 cons1;
|
||||
|
||||
typedef typename detail::add_const_reference<T1>::type t1_cref;
|
||||
typedef typename detail::add_const_reference<T2>::type t2_cref;
|
||||
typedef typename detail::add_const_reference<T3>::type t3_cref;
|
||||
typedef typename detail::add_const_reference<T4>::type t4_cref;
|
||||
typedef typename detail::add_const_reference<T5>::type t5_cref;
|
||||
typedef typename detail::add_const_reference<T6>::type t6_cref;
|
||||
typedef typename detail::add_const_reference<T7>::type t7_cref;
|
||||
typedef typename detail::add_const_reference<T8>::type t8_cref;
|
||||
typedef typename detail::add_const_reference<T9>::type t9_cref;
|
||||
typedef typename detail::add_const_reference<T10>::type t10_cref;
|
||||
public:
|
||||
typedef cons1 inherited;
|
||||
typedef tuple self_type;
|
||||
|
||||
explicit tuple(const T1& t1 = T1(),
|
||||
const T2& t2 = T2(),
|
||||
const T3& t3 = T3(),
|
||||
const T4& t4 = T4(),
|
||||
const T5& t5 = T5(),
|
||||
const T6& t6 = T6(),
|
||||
const T7& t7 = T7(),
|
||||
const T8& t8 = T8(),
|
||||
const T9& t9 = T9(),
|
||||
const T10& t10 = T10()) :
|
||||
tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
||||
{}
|
||||
|
||||
tuple(
|
||||
t1_cref t1,
|
||||
t2_cref t2,
|
||||
t3_cref t3 = T3(),
|
||||
t4_cref t4 = T4(),
|
||||
t5_cref t5 = T5(),
|
||||
t6_cref t6 = T6(),
|
||||
t7_cref t7 = T7(),
|
||||
t8_cref t8 = T8(),
|
||||
t9_cref t9 = T9(),
|
||||
t10_cref t10 = T10()
|
||||
) :
|
||||
cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
|
||||
{
|
||||
}
|
||||
|
||||
explicit tuple(t1_cref t1)
|
||||
: cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
||||
{}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
explicit tuple(const cons<Head, Tail>& other) :
|
||||
tuple(const cons<Head, Tail>& other) :
|
||||
cons1(other.head, other.tail)
|
||||
{
|
||||
}
|
||||
@ -531,7 +617,7 @@ namespace tuples {
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
@ -580,7 +666,7 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2> >
|
||||
tie(T1& t1, T2& t2)
|
||||
{
|
||||
@ -591,8 +677,8 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3> >
|
||||
tie(T1& t1, T2& t2, T3& t3)
|
||||
{
|
||||
@ -604,9 +690,9 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
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)
|
||||
{
|
||||
@ -619,10 +705,10 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
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)
|
||||
{
|
||||
@ -636,11 +722,11 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
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)
|
||||
{
|
||||
@ -655,12 +741,12 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
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)
|
||||
{
|
||||
@ -676,13 +762,13 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
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)
|
||||
{
|
||||
@ -699,14 +785,14 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
detail::assign_to_pointee<T8>,
|
||||
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)
|
||||
{
|
||||
@ -723,15 +809,15 @@ namespace tuples {
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
detail::assign_to_pointee<T8>,
|
||||
detail::assign_to_pointee<T9>,
|
||||
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)
|
||||
{
|
||||
@ -746,10 +832,9 @@ namespace tuples {
|
||||
detail::assign_to_pointee<T9>(&t9),
|
||||
detail::assign_to_pointee<T10>(&t10));
|
||||
}
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
namespace {
|
||||
detail::swallow_assign ignore;
|
||||
}
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
|
||||
detail::swallow_assign const ignore = detail::swallow_assign();
|
||||
|
||||
} // namespace tuples
|
||||
} // namespace boost
|
||||
|
||||
@ -2,14 +2,9 @@
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
@ -18,6 +13,13 @@
|
||||
#ifndef BOOST_TUPLE_HPP
|
||||
#define BOOST_TUPLE_HPP
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
|
||||
// Work around a compiler bug.
|
||||
// boost::python::tuple has to be seen by the compiler before the
|
||||
// boost::tuple class template.
|
||||
namespace boost { namespace python { class tuple; }}
|
||||
#endif
|
||||
|
||||
#include "boost/config.hpp"
|
||||
#include "boost/static_assert.hpp"
|
||||
|
||||
|
||||
@ -3,14 +3,9 @@
|
||||
// Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// For more information, see http://www.boost.org
|
||||
//
|
||||
|
||||
@ -3,14 +3,9 @@
|
||||
// Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@ -36,6 +31,23 @@
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// This is ugly: one should be using twoargument isspace since whitspace can
|
||||
// be locale dependent, in theory at least.
|
||||
// not all libraries implement have the two-arg version, so we need to
|
||||
// use the one-arg one, which one should get with <cctype> but there seem
|
||||
// to be exceptions to this.
|
||||
|
||||
#if !defined (BOOST_NO_STD_LOCALE)
|
||||
|
||||
#include <locale> // for two-arg isspace
|
||||
|
||||
#else
|
||||
|
||||
#include <cctype> // for one-arg (old) isspace
|
||||
#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
|
||||
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
@ -69,9 +81,9 @@ public:
|
||||
// parentheses and space are the default manipulators
|
||||
if (!c) {
|
||||
switch(m) {
|
||||
case open : c = '('; break;
|
||||
case close : c = ')'; break;
|
||||
case delimiter : c = ' '; break;
|
||||
case detail::format_info::open : c = '('; break;
|
||||
case detail::format_info::close : c = ')'; break;
|
||||
case detail::format_info::delimiter : c = ' '; break;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
@ -92,9 +104,9 @@ public:
|
||||
// parentheses and space are the default manipulators
|
||||
if (!c) {
|
||||
switch(m) {
|
||||
case open : c = i.widen('('); break;
|
||||
case close : c = i.widen(')'); break;
|
||||
case delimiter : c = i.widen(' '); break;
|
||||
case detail::format_info::open : c = i.widen('('); break;
|
||||
case detail::format_info::close : c = i.widen(')'); break;
|
||||
case detail::format_info::delimiter : c = i.widen(' '); break;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
@ -328,12 +340,16 @@ extract_and_check_delimiter(
|
||||
{
|
||||
const char d = format_info::get_manipulator(is, del);
|
||||
|
||||
const bool is_delimiter = (!isspace(d) );
|
||||
#if defined (BOOST_NO_STD_LOCALE)
|
||||
const bool is_delimiter = !isspace(d);
|
||||
#else
|
||||
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
|
||||
#endif
|
||||
|
||||
char c;
|
||||
if (is_delimiter) {
|
||||
is >> c;
|
||||
if (c!=d) {
|
||||
if (is.good() && c!=d) {
|
||||
is.setstate(std::ios::failbit);
|
||||
}
|
||||
}
|
||||
@ -415,12 +431,19 @@ extract_and_check_delimiter(
|
||||
{
|
||||
const CharType d = format_info::get_manipulator(is, del);
|
||||
|
||||
const bool is_delimiter = (!isspace(d) );
|
||||
#if defined (BOOST_NO_STD_LOCALE)
|
||||
const bool is_delimiter = !isspace(d);
|
||||
#elif defined ( __BORLANDC__ )
|
||||
const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
|
||||
(is.getloc() ).is( std::ctype_base::space, d);
|
||||
#else
|
||||
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
|
||||
#endif
|
||||
|
||||
CharType c;
|
||||
if (is_delimiter) {
|
||||
is >> c;
|
||||
if (c!=d) {
|
||||
if (is.good() && c!=d) {
|
||||
is.setstate(std::ios::failbit);
|
||||
}
|
||||
}
|
||||
|
||||
13
index.html
Normal file
13
index.html
Normal file
@ -0,0 +1,13 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a>
|
||||
<hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
</body>
|
||||
</html>
|
||||
8
test/Jamfile
Normal file
8
test/Jamfile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
project : requirements <library>/boost/test//boost_test_exec_monitor ;
|
||||
|
||||
test-suite tuple :
|
||||
[ run tuple_test_bench.cpp ]
|
||||
[ run io_test.cpp ]
|
||||
[ run another_tuple_test_bench.cpp ]
|
||||
;
|
||||
@ -1,3 +1,12 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
|
||||
// another_test_bench.cpp --------------------------------
|
||||
|
||||
// This file has various tests to see that things that shouldn't
|
||||
@ -89,12 +98,11 @@ void foo2() {
|
||||
|
||||
void foo4()
|
||||
{
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
double d = 2.7;
|
||||
A a;
|
||||
tuple<int, double&, const A&> t(1, d, a);
|
||||
const tuple<int, double&, const A> ct = t;
|
||||
|
||||
(void)ct;
|
||||
#ifdef E8
|
||||
get<0>(ct) = 5; // can't assign to const
|
||||
#endif
|
||||
@ -105,8 +113,6 @@ void foo4()
|
||||
#ifdef E10
|
||||
dummy(get<5>(ct)); // illegal index
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
// testing copy and assignment with implicit conversions between elements
|
||||
@ -119,9 +125,10 @@ void foo4()
|
||||
|
||||
void foo5() {
|
||||
tuple<char, BB*, BB, DD> t;
|
||||
|
||||
(void)t;
|
||||
tuple<char, char> aaa;
|
||||
tuple<int, int> bbb(aaa);
|
||||
(void)bbb;
|
||||
// tuple<int, AA*, CC, CC> a = t;
|
||||
// a = t;
|
||||
}
|
||||
|
||||
@ -1,3 +1,11 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// -- io_test.cpp -----------------------------------------------
|
||||
//
|
||||
// Testing the I/O facilities of tuples
|
||||
@ -19,8 +27,6 @@
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
#include "boost/config.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
@ -33,7 +39,8 @@ typedef istringstream useThisIStringStream;
|
||||
#endif
|
||||
|
||||
int test_main(int argc, char * argv[] ) {
|
||||
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
using boost::tuples::set_close;
|
||||
using boost::tuples::set_open;
|
||||
using boost::tuples::set_delimiter;
|
||||
@ -45,7 +52,7 @@ int test_main(int argc, char * argv[] ) {
|
||||
os1 << set_close(']');
|
||||
os1 << set_delimiter(',');
|
||||
os1 << make_tuple(1, 2, 3);
|
||||
BOOST_TEST (os1.str() == std::string("[1,2,3]") );
|
||||
BOOST_CHECK (os1.str() == std::string("[1,2,3]") );
|
||||
|
||||
{
|
||||
useThisOStringStream os2;
|
||||
@ -55,13 +62,13 @@ int test_main(int argc, char * argv[] ) {
|
||||
os2 << set_delimiter(':');
|
||||
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
|
||||
BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
|
||||
BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
|
||||
#endif
|
||||
}
|
||||
|
||||
// The format is still [a, b, c] for os1
|
||||
os1 << make_tuple(1, 2, 3);
|
||||
BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
|
||||
BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
|
||||
|
||||
ofstream tmp("temp.tmp");
|
||||
|
||||
@ -79,13 +86,13 @@ int test_main(int argc, char * argv[] ) {
|
||||
|
||||
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
tmp3 >> j;
|
||||
BOOST_TEST (tmp3.good() );
|
||||
BOOST_CHECK (tmp3.good() );
|
||||
#endif
|
||||
|
||||
tmp3 >> set_delimiter(':');
|
||||
tuple<int, int, int> i;
|
||||
tmp3 >> i;
|
||||
BOOST_TEST (tmp3.good() );
|
||||
BOOST_CHECK (tmp3.good() );
|
||||
|
||||
tmp3.close();
|
||||
|
||||
@ -94,8 +101,8 @@ int test_main(int argc, char * argv[] ) {
|
||||
useThisIStringStream is("(100 200 300)");
|
||||
|
||||
tuple<int, int, int> ti;
|
||||
BOOST_TEST(is >> ti);
|
||||
BOOST_TEST(ti == make_tuple(100, 200, 300));
|
||||
BOOST_CHECK(bool(is >> ti));
|
||||
BOOST_CHECK(ti == make_tuple(100, 200, 300));
|
||||
|
||||
|
||||
// Note that strings are problematic:
|
||||
|
||||
@ -1,3 +1,11 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// tuple_test_bench.cpp --------------------------------
|
||||
|
||||
#define BOOST_INCLUDE_MAIN // for testing, include rather than link
|
||||
@ -7,6 +15,9 @@
|
||||
|
||||
#include "boost/tuple/tuple_comparison.hpp"
|
||||
|
||||
#include "boost/type_traits/is_const.hpp"
|
||||
|
||||
#include "boost/ref.hpp"
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
@ -66,7 +77,6 @@ public:
|
||||
|
||||
typedef tuple<int> t1;
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
typedef tuple<double&, const double&, const double, double*, const double*> t2;
|
||||
typedef tuple<A, int(*)(char, int), C> t3;
|
||||
typedef tuple<std::string, std::pair<A, B> > t4;
|
||||
@ -77,22 +87,16 @@ typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
|
||||
typedef tuple<B(A::*)(C&), A&> t7;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// -tuple construction tests ---------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
no_copy y;
|
||||
tuple<no_copy&> x = tuple<no_copy&>(y); // ok
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
char cs[10];
|
||||
tuple<char(&)[10]> v2(cs); // ok
|
||||
#endif
|
||||
|
||||
void
|
||||
construction_test()
|
||||
@ -103,32 +107,32 @@ construction_test()
|
||||
// MSVC 6.0 just cannot find get without the namespace qualifier
|
||||
|
||||
tuple<int> t1;
|
||||
BOOST_TEST(get<0>(t1) == int());
|
||||
BOOST_CHECK(get<0>(t1) == int());
|
||||
|
||||
tuple<float> t2(5.5f);
|
||||
BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
|
||||
BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
|
||||
|
||||
tuple<foo> t3(foo(12));
|
||||
BOOST_TEST(get<0>(t3) == foo(12));
|
||||
BOOST_CHECK(get<0>(t3) == foo(12));
|
||||
|
||||
tuple<double> t4(t2);
|
||||
BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
|
||||
BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
|
||||
|
||||
tuple<int, float> t5;
|
||||
BOOST_TEST(get<0>(t5) == int());
|
||||
BOOST_TEST(get<1>(t5) == float());
|
||||
BOOST_CHECK(get<0>(t5) == int());
|
||||
BOOST_CHECK(get<1>(t5) == float());
|
||||
|
||||
tuple<int, float> t6(12, 5.5f);
|
||||
BOOST_TEST(get<0>(t6) == 12);
|
||||
BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
|
||||
BOOST_CHECK(get<0>(t6) == 12);
|
||||
BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
|
||||
|
||||
tuple<int, float> t7(t6);
|
||||
BOOST_TEST(get<0>(t7) == 12);
|
||||
BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
|
||||
BOOST_CHECK(get<0>(t7) == 12);
|
||||
BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
|
||||
|
||||
tuple<long, double> t8(t6);
|
||||
BOOST_TEST(get<0>(t8) == 12);
|
||||
BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
|
||||
BOOST_CHECK(get<0>(t8) == 12);
|
||||
BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
|
||||
|
||||
dummy(
|
||||
tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
|
||||
@ -147,12 +151,10 @@ construction_test()
|
||||
// dummy(tuple<double&>()); // should fail, not defaults for references
|
||||
// dummy(tuple<const double&>()); // likewise
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
double dd = 5;
|
||||
dummy(tuple<double&>(dd)); // ok
|
||||
|
||||
dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
|
||||
#endif
|
||||
|
||||
// dummy(tuple<double&>(dd+3.14)); // should fail,
|
||||
// // temporary to non-const reference
|
||||
@ -165,7 +167,6 @@ construction_test()
|
||||
|
||||
void element_access_test()
|
||||
{
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
double d = 2.7;
|
||||
A a;
|
||||
tuple<int, double&, const A&, int> t(1, d, a, 2);
|
||||
@ -174,58 +175,40 @@ void element_access_test()
|
||||
int i = get<0>(t);
|
||||
int i2 = get<3>(t);
|
||||
|
||||
BOOST_TEST(i == 1 && i2 == 2);
|
||||
BOOST_CHECK(i == 1 && i2 == 2);
|
||||
|
||||
int j = get<0>(ct);
|
||||
BOOST_TEST(j == 1);
|
||||
BOOST_CHECK(j == 1);
|
||||
|
||||
get<0>(t) = 5;
|
||||
BOOST_TEST(t.head == 5);
|
||||
BOOST_CHECK(t.head == 5);
|
||||
|
||||
// get<0>(ct) = 5; // can't assign to const
|
||||
|
||||
double e = get<1>(t);
|
||||
BOOST_TEST(e > 2.69 && e < 2.71);
|
||||
BOOST_CHECK(e > 2.69 && e < 2.71);
|
||||
|
||||
get<1>(t) = 3.14+i;
|
||||
BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
|
||||
BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);
|
||||
|
||||
// get<4>(t) = A(); // can't assign to const
|
||||
// dummy(get<5>(ct)); // illegal index
|
||||
|
||||
++get<0>(t);
|
||||
BOOST_TEST(get<0>(t) == 6);
|
||||
BOOST_CHECK(get<0>(t) == 6);
|
||||
|
||||
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
|
||||
#endif
|
||||
|
||||
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
|
||||
#endif
|
||||
|
||||
|
||||
dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
|
||||
#else
|
||||
double d = 2.7;
|
||||
A a;
|
||||
tuple<int, double, const A, int> t(1, d, a, 2);
|
||||
|
||||
int i = get<0>(t);
|
||||
int i2 = get<3>(t);
|
||||
|
||||
BOOST_TEST(i == 1 && i2 == 2);
|
||||
|
||||
get<0>(t) = 5;
|
||||
BOOST_TEST(t.head == 5);
|
||||
|
||||
// get<0>(ct) = 5; // can't assign to const
|
||||
|
||||
double e = get<1>(t);
|
||||
BOOST_TEST(e > 2.69 && e < 2.71);
|
||||
|
||||
get<1>(t) = 3.14+i;
|
||||
BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
|
||||
|
||||
// get<4>(t) = A(); // can't assign to const
|
||||
// dummy(get<5>(ct)); // illegal index
|
||||
|
||||
++get<0>(t);
|
||||
BOOST_TEST(get<0>(t) == 6);
|
||||
|
||||
dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@ -241,13 +224,13 @@ copy_test()
|
||||
tuple<int, char> t1(4, 'a');
|
||||
tuple<int, char> t2(5, 'b');
|
||||
t2 = t1;
|
||||
BOOST_TEST(get<0>(t1) == get<0>(t2));
|
||||
BOOST_TEST(get<1>(t1) == get<1>(t2));
|
||||
BOOST_CHECK(get<0>(t1) == get<0>(t2));
|
||||
BOOST_CHECK(get<1>(t1) == get<1>(t2));
|
||||
|
||||
tuple<long, std::string> t3(2, "a");
|
||||
t3 = t1;
|
||||
BOOST_TEST((double)get<0>(t1) == get<0>(t3));
|
||||
BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
|
||||
BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
|
||||
BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);
|
||||
|
||||
// testing copy and assignment with implicit conversions between elements
|
||||
// testing tie
|
||||
@ -259,9 +242,9 @@ copy_test()
|
||||
int i; char c; double d;
|
||||
tie(i, c, d) = make_tuple(1, 'a', 5.5);
|
||||
|
||||
BOOST_TEST(i==1);
|
||||
BOOST_TEST(c=='a');
|
||||
BOOST_TEST(d>5.4 && d<5.6);
|
||||
BOOST_CHECK(i==1);
|
||||
BOOST_CHECK(c=='a');
|
||||
BOOST_CHECK(d>5.4 && d<5.6);
|
||||
}
|
||||
|
||||
void
|
||||
@ -273,10 +256,10 @@ mutate_test()
|
||||
get<2>(t1) = false;
|
||||
get<3>(t1) = foo(5);
|
||||
|
||||
BOOST_TEST(get<0>(t1) == 6);
|
||||
BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
|
||||
BOOST_TEST(get<2>(t1) == false);
|
||||
BOOST_TEST(get<3>(t1) == foo(5));
|
||||
BOOST_CHECK(get<0>(t1) == 6);
|
||||
BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
|
||||
BOOST_CHECK(get<2>(t1) == false);
|
||||
BOOST_CHECK(get<3>(t1) == foo(5));
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@ -287,40 +270,36 @@ void
|
||||
make_tuple_test()
|
||||
{
|
||||
tuple<int, char> t1 = make_tuple(5, 'a');
|
||||
BOOST_TEST(get<0>(t1) == 5);
|
||||
BOOST_TEST(get<1>(t1) == 'a');
|
||||
BOOST_CHECK(get<0>(t1) == 5);
|
||||
BOOST_CHECK(get<1>(t1) == 'a');
|
||||
|
||||
tuple<int, std::string> t2;
|
||||
t2 = make_tuple((short int)2, std::string("Hi"));
|
||||
BOOST_TEST(get<0>(t2) == 2);
|
||||
BOOST_TEST(get<1>(t2) == "Hi");
|
||||
BOOST_CHECK(get<0>(t2) == 2);
|
||||
BOOST_CHECK(get<1>(t2) == "Hi");
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
A a; B b;
|
||||
A a = A(); B b;
|
||||
const A ca = a;
|
||||
make_tuple(cref(a), b);
|
||||
make_tuple(ref(a), b);
|
||||
make_tuple(ref(a), cref(b));
|
||||
make_tuple(boost::cref(a), b);
|
||||
make_tuple(boost::ref(a), b);
|
||||
make_tuple(boost::ref(a), boost::cref(b));
|
||||
|
||||
make_tuple(ref(ca));
|
||||
#endif
|
||||
make_tuple(boost::ref(ca));
|
||||
|
||||
// the result of make_tuple is assignable:
|
||||
BOOST_TEST(make_tuple(2, 4, 6) ==
|
||||
BOOST_CHECK(make_tuple(2, 4, 6) ==
|
||||
(make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
make_tuple("Donald", "Daisy"); // should work;
|
||||
#endif
|
||||
#endif
|
||||
// std::make_pair("Doesn't","Work"); // fails
|
||||
|
||||
// You can store a reference to a function in a tuple
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
tuple<void(&)()> adf(make_tuple_test);
|
||||
|
||||
dummy(adf); // avoid warning for unused variable
|
||||
#endif
|
||||
|
||||
// But make_tuple doesn't work
|
||||
// with function references, since it creates a const qualified function type
|
||||
@ -357,19 +336,19 @@ tie_test()
|
||||
foo c(5);
|
||||
|
||||
tie(a, b, c) = make_tuple(2, 'a', foo(3));
|
||||
BOOST_TEST(a == 2);
|
||||
BOOST_TEST(b == 'a');
|
||||
BOOST_TEST(c == foo(3));
|
||||
BOOST_CHECK(a == 2);
|
||||
BOOST_CHECK(b == 'a');
|
||||
BOOST_CHECK(c == foo(3));
|
||||
|
||||
tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
|
||||
BOOST_TEST(a == 5);
|
||||
BOOST_TEST(b == 'a');
|
||||
BOOST_TEST(c == foo(5));
|
||||
BOOST_CHECK(a == 5);
|
||||
BOOST_CHECK(b == 'a');
|
||||
BOOST_CHECK(c == foo(5));
|
||||
|
||||
// testing assignment from std::pair
|
||||
int i, j;
|
||||
tie (i, j) = std::make_pair(1, 2);
|
||||
BOOST_TEST(i == 1 && j == 2);
|
||||
BOOST_CHECK(i == 1 && j == 2);
|
||||
|
||||
tuple<int, int, float> ta;
|
||||
#ifdef E11
|
||||
@ -389,13 +368,13 @@ equality_test()
|
||||
{
|
||||
tuple<int, char> t1(5, 'a');
|
||||
tuple<int, char> t2(5, 'a');
|
||||
BOOST_TEST(t1 == t2);
|
||||
BOOST_CHECK(t1 == t2);
|
||||
|
||||
tuple<int, char> t3(5, 'b');
|
||||
tuple<int, char> t4(2, 'a');
|
||||
BOOST_TEST(t1 != t3);
|
||||
BOOST_TEST(t1 != t4);
|
||||
BOOST_TEST(!(t1 != t2));
|
||||
BOOST_CHECK(t1 != t3);
|
||||
BOOST_CHECK(t1 != t4);
|
||||
BOOST_CHECK(!(t1 != t2));
|
||||
}
|
||||
|
||||
|
||||
@ -409,14 +388,14 @@ ordering_test()
|
||||
tuple<int, float> t1(4, 3.3f);
|
||||
tuple<short, float> t2(5, 3.3f);
|
||||
tuple<long, double> t3(5, 4.4);
|
||||
BOOST_TEST(t1 < t2);
|
||||
BOOST_TEST(t1 <= t2);
|
||||
BOOST_TEST(t2 > t1);
|
||||
BOOST_TEST(t2 >= t1);
|
||||
BOOST_TEST(t2 < t3);
|
||||
BOOST_TEST(t2 <= t3);
|
||||
BOOST_TEST(t3 > t2);
|
||||
BOOST_TEST(t3 >= t2);
|
||||
BOOST_CHECK(t1 < t2);
|
||||
BOOST_CHECK(t1 <= t2);
|
||||
BOOST_CHECK(t2 > t1);
|
||||
BOOST_CHECK(t2 >= t1);
|
||||
BOOST_CHECK(t2 < t3);
|
||||
BOOST_CHECK(t2 <= t3);
|
||||
BOOST_CHECK(t3 > t2);
|
||||
BOOST_CHECK(t3 >= t2);
|
||||
|
||||
}
|
||||
|
||||
@ -426,7 +405,6 @@ ordering_test()
|
||||
// ----------------------------------------------------------------------------
|
||||
void cons_test()
|
||||
{
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
using tuples::cons;
|
||||
using tuples::null_type;
|
||||
|
||||
@ -434,11 +412,10 @@ void cons_test()
|
||||
cons<const int, cons<volatile float, null_type> > b(2,a);
|
||||
int i = 3;
|
||||
cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
|
||||
BOOST_TEST(make_tuple(3,2,1)==c);
|
||||
BOOST_CHECK(make_tuple(3,2,1)==c);
|
||||
|
||||
cons<char, cons<int, cons<float, null_type> > > x;
|
||||
dummy(x);
|
||||
#endif
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@ -447,8 +424,8 @@ void cons_test()
|
||||
void const_tuple_test()
|
||||
{
|
||||
const tuple<int, float> t1(5, 3.3f);
|
||||
BOOST_TEST(get<0>(t1) == 5);
|
||||
BOOST_TEST(get<1>(t1) == 3.3f);
|
||||
BOOST_CHECK(get<0>(t1) == 5);
|
||||
BOOST_CHECK(get<1>(t1) == 3.3f);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user