[thirdparty/gcc.git] / libstdc++-v3 / include / tr1 / tuple

// class template tuple -*- C++ -*-

// Copyright (C) 2004-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file tr1/tuple
*  This is a TR1 C++ Library header.
*/

// Chris Jefferson <chris@bubblescope.net>
// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>

#ifndef _GLIBCXX_TR1_TUPLE
#define _GLIBCXX_TR1_TUPLE 1

#pragma GCC system_header

#include <utility>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace tr1
{
  // Adds a const reference to a non-reference type.
  template<typename _Tp>
    struct __add_c_ref
    { typedef const _Tp& type; };

  template<typename _Tp>
    struct __add_c_ref<_Tp&>
    { typedef _Tp& type; };

  // Adds a reference to a non-reference type.
  template<typename _Tp>
    struct __add_ref
    { typedef _Tp& type; };

  template<typename _Tp>
    struct __add_ref<_Tp&>
    { typedef _Tp& type; };

  /**
   * Contains the actual implementation of the @c tuple template, stored
   * as a recursive inheritance hierarchy from the first element (most
   * derived class) to the last (least derived class). The @c Idx
   * parameter gives the 0-based index of the element stored at this
   * point in the hierarchy; we use it to implement a constant-time
   * get() operation.
   */
  template<int _Idx, typename... _Elements>
    struct _Tuple_impl; 

  /**
   * Zero-element tuple implementation. This is the basis case for the 
   * inheritance recursion.
   */
  template<int _Idx>
    struct _Tuple_impl<_Idx> { };

  /**
   * Recursive tuple implementation. Here we store the @c Head element
   * and derive from a @c Tuple_impl containing the remaining elements
   * (which contains the @c Tail).
   */
  template<int _Idx, typename _Head, typename... _Tail>
    struct _Tuple_impl<_Idx, _Head, _Tail...>
    : public _Tuple_impl<_Idx + 1, _Tail...>
    {
      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
      
      _Head _M_head;
      
      _Inherited&       _M_tail()       { return *this; }
      const _Inherited& _M_tail() const { return *this; }
      
      _Tuple_impl() : _Inherited(), _M_head() { }
      
      explicit 
      _Tuple_impl(typename __add_c_ref<_Head>::type __head,
		  typename __add_c_ref<_Tail>::type... __tail)
      : _Inherited(__tail...), _M_head(__head) { }

      template<typename... _UElements>
      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }

      _Tuple_impl(const _Tuple_impl& __in)
      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
     
      template<typename... _UElements>
        _Tuple_impl&
        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
        {
	  _M_head = __in._M_head;
	  _M_tail() = __in._M_tail();
	  return *this;
	}

      _Tuple_impl&
      operator=(const _Tuple_impl& __in)
      {
	_M_head = __in._M_head;
	_M_tail() = __in._M_tail();
	return *this;
      }
    };

  template<typename... _Elements> 
    class tuple : public _Tuple_impl<0, _Elements...>
    {
      typedef _Tuple_impl<0, _Elements...> _Inherited;

    public:
      tuple() : _Inherited() { }

      explicit
      tuple(typename __add_c_ref<_Elements>::type... __elements)
      : _Inherited(__elements...) { }

      template<typename... _UElements>
        tuple(const tuple<_UElements...>& __in)
	: _Inherited(__in) { }

      tuple(const tuple& __in)
      : _Inherited(__in) { }

      template<typename... _UElements>
        tuple&
        operator=(const tuple<_UElements...>& __in)
        {
	  static_cast<_Inherited&>(*this) = __in;
	  return *this;
	}

      tuple&
      operator=(const tuple& __in)
      {
	static_cast<_Inherited&>(*this) = __in;
	return *this;
      }
    };

  template<> class tuple<> { };

  // 2-element tuple, with construction and assignment from a pair.
  template<typename _T1, typename _T2>
    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
    {
      typedef _Tuple_impl<0, _T1, _T2> _Inherited;

    public:
      tuple() : _Inherited() { }

      explicit
      tuple(typename __add_c_ref<_T1>::type __a1,
	    typename __add_c_ref<_T2>::type __a2)
      : _Inherited(__a1, __a2) { }

      template<typename _U1, typename _U2>
        tuple(const tuple<_U1, _U2>& __in)
	: _Inherited(__in) { }

      tuple(const tuple& __in)
      : _Inherited(__in) { }

      template<typename _U1, typename _U2>
        tuple(const pair<_U1, _U2>& __in)
	: _Inherited(_Tuple_impl<0, 
		     typename __add_c_ref<_U1>::type,
		     typename __add_c_ref<_U2>::type>(__in.first, 
						      __in.second))
        { }
  
      template<typename _U1, typename _U2>
        tuple&
        operator=(const tuple<_U1, _U2>& __in)
        {
	  static_cast<_Inherited&>(*this) = __in;
	  return *this;
	}

      tuple&
      operator=(const tuple& __in)
      {
	static_cast<_Inherited&>(*this) = __in;
	return *this;
      }

      template<typename _U1, typename _U2>
        tuple&
        operator=(const pair<_U1, _U2>& __in)
        {
	  this->_M_head = __in.first;
	  this->_M_tail()._M_head = __in.second;
	  return *this;
	}
    };

  
  /// Gives the type of the ith element of a given tuple type.
  template<int __i, typename _Tp>
    struct tuple_element;

  /**
   * Recursive case for tuple_element: strip off the first element in
   * the tuple and retrieve the (i-1)th element of the remaining tuple.
   */
  template<int __i, typename _Head, typename... _Tail>
    struct tuple_element<__i, tuple<_Head, _Tail...> >
    : tuple_element<__i - 1, tuple<_Tail...> > { };

  /**
   * Basis case for tuple_element: The first element is the one we're seeking.
   */
  template<typename _Head, typename... _Tail>
    struct tuple_element<0, tuple<_Head, _Tail...> >
    {
      typedef _Head type;
    };

  /// Finds the size of a given tuple type.
  template<typename _Tp>
    struct tuple_size;

  /// class tuple_size
  template<typename... _Elements>
    struct tuple_size<tuple<_Elements...> >
    {
      static const int value = sizeof...(_Elements);
    };

  template<typename... _Elements>
    const int tuple_size<tuple<_Elements...> >::value;

  template<int __i, typename _Head, typename... _Tail>
    inline typename __add_ref<_Head>::type
    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
    {
      return __t._M_head;
    }

  template<int __i, typename _Head, typename... _Tail>
    inline typename __add_c_ref<_Head>::type
    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
    {
      return __t._M_head;
    }

  // Return a reference (const reference) to the ith element of a tuple.
  // Any const or non-const ref elements are returned with their original type.
  template<int __i, typename... _Elements>
    inline typename __add_ref<
                      typename tuple_element<__i, tuple<_Elements...> >::type
                    >::type
    get(tuple<_Elements...>& __t)
    { 
      return __get_helper<__i>(__t); 
    }

  template<int __i, typename... _Elements>
    inline typename __add_c_ref<
                      typename tuple_element<__i, tuple<_Elements...> >::type
                    >::type
    get(const tuple<_Elements...>& __t)
    {
      return __get_helper<__i>(__t);
    }

  // This class helps construct the various comparison operations on tuples
  template<int __check_equal_size, int __i, int __j,
	   typename _Tp, typename _Up>
    struct __tuple_compare;

  template<int __i, int __j, typename _Tp, typename _Up>
    struct __tuple_compare<0, __i, __j, _Tp, _Up>
    {
      static bool __eq(const _Tp& __t, const _Up& __u)
      {
	return (get<__i>(__t) == get<__i>(__u) &&
		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
      }
     
      static bool __less(const _Tp& __t, const _Up& __u)
      {
	return ((get<__i>(__t) < get<__i>(__u))
		|| !(get<__i>(__u) < get<__i>(__t)) &&
		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
      }
    };

  template<int __i, typename _Tp, typename _Up>
    struct __tuple_compare<0, __i, __i, _Tp, _Up>
    {
      static bool __eq(const _Tp&, const _Up&)
      { return true; }
     
      static bool __less(const _Tp&, const _Up&)
      { return false; }
    };

  template<typename... _TElements, typename... _UElements>
    bool
    operator==(const tuple<_TElements...>& __t,
	       const tuple<_UElements...>& __u)
    {
      typedef tuple<_TElements...> _Tp;
      typedef tuple<_UElements...> _Up;
      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
    }

  template<typename... _TElements, typename... _UElements>
    bool
    operator<(const tuple<_TElements...>& __t,
	      const tuple<_UElements...>& __u)
    {
      typedef tuple<_TElements...> _Tp;
      typedef tuple<_UElements...> _Up;
      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
    }

  template<typename... _TElements, typename... _UElements>
    inline bool
    operator!=(const tuple<_TElements...>& __t,
	       const tuple<_UElements...>& __u)
    { return !(__t == __u); }

  template<typename... _TElements, typename... _UElements>
    inline bool
    operator>(const tuple<_TElements...>& __t,
	      const tuple<_UElements...>& __u)
    { return __u < __t; }

  template<typename... _TElements, typename... _UElements>
    inline bool
    operator<=(const tuple<_TElements...>& __t,
	       const tuple<_UElements...>& __u)
    { return !(__u < __t); }

  template<typename... _TElements, typename... _UElements>
    inline bool
    operator>=(const tuple<_TElements...>& __t,
	       const tuple<_UElements...>& __u)
    { return !(__t < __u); }

  template<typename _Tp>
    class reference_wrapper;

  // Helper which adds a reference to a type when given a reference_wrapper
  template<typename _Tp>
    struct __strip_reference_wrapper
    {
      typedef _Tp __type;
    };

  template<typename _Tp>
    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
    {
      typedef _Tp& __type;
    };

  template<typename _Tp>
    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
    {
      typedef _Tp& __type;
    };

  template<typename... _Elements>
    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
    make_tuple(_Elements... __args)
    {
      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
        __result_type;
      return __result_type(__args...);
    }

  template<typename... _Elements>
    inline tuple<_Elements&...>
    tie(_Elements&... __args)
    {
      return tuple<_Elements&...>(__args...);
    }

  // A class (and instance) which can be used in 'tie' when an element
  // of a tuple is not required
  struct _Swallow_assign
  {
    template<class _Tp>
      _Swallow_assign&
      operator=(const _Tp&)
      { return *this; }
  };

  // TODO: Put this in some kind of shared file.
  namespace
  {
    _Swallow_assign ignore;
  }; // anonymous namespace
}

_GLIBCXX_END_NAMESPACE_VERSION
}

#endif // _GLIBCXX_TR1_TUPLE
Commit	Line	Data
a520f0b0 BK	1	// class template tuple -- C++ --
a520f0b0 BK	2
cbe34bb5	3	// Copyright (C) 2004-2017 Free Software Foundation, Inc.
a520f0b0 BK	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
748086b7	8	// Free Software Foundation; either version 3, or (at your option)
a520f0b0 BK	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
748086b7 JJ	16	// Under Section 7 of GPL version 3, you are granted additional
	17	// permissions described in the GCC Runtime Library Exception, version
	18	// 3.1, as published by the Free Software Foundation.
a520f0b0	19
748086b7 JJ	20	// You should have received a copy of the GNU General Public License and
	21	// a copy of the GCC Runtime Library Exception along with this program;
	22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	23	// <http://www.gnu.org/licenses/>.
909a9d44	24
143c27b0	25	/** @file tr1/tuple
59cffcf6 DG	26	* This is a TR1 C++ Library header.
59cffcf6 DG	27	*/
00aca6e8	28
f2ede5d6	29	// Chris Jefferson <chris@bubblescope.net>
9eeea761	30	// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
f2ede5d6	31
e133ace8 PC	32	#ifndef _GLIBCXX_TR1_TUPLE
e133ace8 PC	33	#define _GLIBCXX_TR1_TUPLE 1
a520f0b0	34
9eeea761 DG	35	#pragma GCC system_header
9eeea761 DG	36
e133ace8	37	#include <utility>
78a53887	38
12ffa228	39	namespace std _GLIBCXX_VISIBILITY(default)
894d0b15	40	{
12ffa228 BK	41	_GLIBCXX_BEGIN_NAMESPACE_VERSION
12ffa228 BK	42
4a15d842 FD	43	namespace tr1
4a15d842 FD	44	{
894d0b15 CF	45	// Adds a const reference to a non-reference type.
	46	template<typename _Tp>
	47	struct __add_c_ref
	48	{ typedef const _Tp& type; };
	49
	50	template<typename _Tp>
	51	struct __add_c_ref<_Tp&>
	52	{ typedef _Tp& type; };
	53
	54	// Adds a reference to a non-reference type.
	55	template<typename _Tp>
	56	struct __add_ref
	57	{ typedef _Tp& type; };
	58
	59	template<typename _Tp>
	60	struct __add_ref<_Tp&>
	61	{ typedef _Tp& type; };
	62
	63	/**
894d0b15 CF	64	* Contains the actual implementation of the @c tuple template, stored
	65	* as a recursive inheritance hierarchy from the first element (most
	66	* derived class) to the last (least derived class). The @c Idx
	67	* parameter gives the 0-based index of the element stored at this
	68	* point in the hierarchy; we use it to implement a constant-time
	69	* get() operation.
894d0b15 CF	70	*/
	71	template<int _Idx, typename... _Elements>
	72	struct _Tuple_impl;
	73
	74	/**
894d0b15 CF	75	* Zero-element tuple implementation. This is the basis case for the
894d0b15 CF	76	* inheritance recursion.
894d0b15 CF	77	*/
	78	template<int _Idx>
	79	struct _Tuple_impl<_Idx> { };
	80
	81	/**
894d0b15 CF	82	* Recursive tuple implementation. Here we store the @c Head element
	83	* and derive from a @c Tuple_impl containing the remaining elements
	84	* (which contains the @c Tail).
894d0b15 CF	85	*/
	86	template<int _Idx, typename _Head, typename... _Tail>
	87	struct _Tuple_impl<_Idx, _Head, _Tail...>
	88	: public _Tuple_impl<_Idx + 1, _Tail...>
	89	{
	90	typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
	91
	92	_Head _M_head;
	93
	94	_Inherited& _M_tail() { return *this; }
	95	const _Inherited& _M_tail() const { return *this; }
	96
	97	_Tuple_impl() : _Inherited(), _M_head() { }
	98
	99	explicit
	100	_Tuple_impl(typename __add_c_ref<_Head>::type __head,
	101	typename __add_c_ref<_Tail>::type... __tail)
	102	: _Inherited(__tail...), _M_head(__head) { }
	103
	104	template<typename... _UElements>
	105	_Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
	106	: _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
	107
	108	_Tuple_impl(const _Tuple_impl& __in)
	109	: _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
	110
	111	template<typename... _UElements>
	112	_Tuple_impl&
	113	operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
	114	{
	115	_M_head = __in._M_head;
	116	_M_tail() = __in._M_tail();
	117	return *this;
	118	}
	119
	120	_Tuple_impl&
	121	operator=(const _Tuple_impl& __in)
	122	{
	123	_M_head = __in._M_head;
	124	_M_tail() = __in._M_tail();
	125	return *this;
	126	}
	127	};
	128
	129	template<typename... _Elements>
	130	class tuple : public _Tuple_impl<0, _Elements...>
	131	{
	132	typedef _Tuple_impl<0, _Elements...> _Inherited;
	133
	134	public:
	135	tuple() : _Inherited() { }
	136
	137	explicit
	138	tuple(typename __add_c_ref<_Elements>::type... __elements)
	139	: _Inherited(__elements...) { }
	140
	141	template<typename... _UElements>
	142	tuple(const tuple<_UElements...>& __in)
	143	: _Inherited(__in) { }
	144
	145	tuple(const tuple& __in)
	146	: _Inherited(__in) { }
	147
	148	template<typename... _UElements>
149	tuple&
150	operator=(const tuple<_UElements...>& __in)
151	{
152	static_cast<_Inherited&>(*this) = __in;
153	return *this;
154	}
155
156	tuple&
157	operator=(const tuple& __in)
158	{
159	static_cast<_Inherited&>(*this) = __in;
160	return *this;
161	}
162	};
163
164	template<> class tuple<> { };
165
166	// 2-element tuple, with construction and assignment from a pair.
167	template<typename _T1, typename _T2>
168	class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
169	{
170	typedef _Tuple_impl<0, _T1, _T2> _Inherited;
171
172	public:
173	tuple() : _Inherited() { }
174
175	explicit
176	tuple(typename __add_c_ref<_T1>::type __a1,
177	typename __add_c_ref<_T2>::type __a2)
178	: _Inherited(__a1, __a2) { }
179
180	template<typename _U1, typename _U2>
181	tuple(const tuple<_U1, _U2>& __in)
182	: _Inherited(__in) { }
183
184	tuple(const tuple& __in)
185	: _Inherited(__in) { }
186
187	template<typename _U1, typename _U2>
188	tuple(const pair<_U1, _U2>& __in)
189	: _Inherited(_Tuple_impl<0,
190	typename __add_c_ref<_U1>::type,
191	typename __add_c_ref<_U2>::type>(__in.first,
192	__in.second))
193	{ }
194
195	template<typename _U1, typename _U2>
196	tuple&
197	operator=(const tuple<_U1, _U2>& __in)
198	{
199	static_cast<_Inherited&>(*this) = __in;
200	return *this;
201	}
202
203	tuple&
204	operator=(const tuple& __in)
205	{
206	static_cast<_Inherited&>(*this) = __in;
207	return *this;
208	}
209
210	template<typename _U1, typename _U2>
211	tuple&
212	operator=(const pair<_U1, _U2>& __in)
213	{
214	this->_M_head = __in.first;
215	this->_M_tail()._M_head = __in.second;
216	return *this;
217	}
218	};
219
220
221	/// Gives the type of the ith element of a given tuple type.
222	template<int __i, typename _Tp>
223	struct tuple_element;
224
225	/**
894d0b15 CF	226	* Recursive case for tuple_element: strip off the first element in
894d0b15 CF	227	* the tuple and retrieve the (i-1)th element of the remaining tuple.
894d0b15 CF	228	*/
	229	template<int __i, typename _Head, typename... _Tail>
	230	struct tuple_element<__i, tuple<_Head, _Tail...> >
	231	: tuple_element<__i - 1, tuple<_Tail...> > { };
	232
	233	/**
894d0b15	234	* Basis case for tuple_element: The first element is the one we're seeking.
894d0b15 CF	235	*/
	236	template<typename _Head, typename... _Tail>
	237	struct tuple_element<0, tuple<_Head, _Tail...> >
	238	{
	239	typedef _Head type;
	240	};
	241
	242	/// Finds the size of a given tuple type.
	243	template<typename _Tp>
	244	struct tuple_size;
	245
939759fc	246	/// class tuple_size
894d0b15 CF	247	template<typename... _Elements>
	248	struct tuple_size<tuple<_Elements...> >
	249	{
	250	static const int value = sizeof...(_Elements);
	251	};
	252
	253	template<typename... _Elements>
	254	const int tuple_size<tuple<_Elements...> >::value;
	255
	256	template<int __i, typename _Head, typename... _Tail>
	257	inline typename __add_ref<_Head>::type
	258	__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
	259	{
	260	return __t._M_head;
	261	}
	262
	263	template<int __i, typename _Head, typename... _Tail>
	264	inline typename __add_c_ref<_Head>::type
	265	__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
	266	{
	267	return __t._M_head;
	268	}
	269
	270	// Return a reference (const reference) to the ith element of a tuple.
	271	// Any const or non-const ref elements are returned with their original type.
	272	template<int __i, typename... _Elements>
	273	inline typename __add_ref<
	274	typename tuple_element<__i, tuple<_Elements...> >::type
	275	>::type
	276	get(tuple<_Elements...>& __t)
	277	{
	278	return __get_helper<__i>(__t);
	279	}
	280
	281	template<int __i, typename... _Elements>
	282	inline typename __add_c_ref<
	283	typename tuple_element<__i, tuple<_Elements...> >::type
	284	>::type
	285	get(const tuple<_Elements...>& __t)
	286	{
	287	return __get_helper<__i>(__t);
	288	}
	289
	290	// This class helps construct the various comparison operations on tuples
	291	template<int __check_equal_size, int __i, int __j,
	292	typename _Tp, typename _Up>
	293	struct __tuple_compare;
	294
	295	template<int __i, int __j, typename _Tp, typename _Up>
	296	struct __tuple_compare<0, __i, __j, _Tp, _Up>
	297	{
	298	static bool __eq(const _Tp& __t, const _Up& __u)
	299	{
	300	return (get<__i>(__t) == get<__i>(__u) &&
	301	__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
	302	}
	303
	304	static bool __less(const _Tp& __t, const _Up& __u)
	305	{
	306	return ((get<__i>(__t) < get<__i>(__u))
	307	\|\| !(get<__i>(__u) < get<__i>(__t)) &&
	308	__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
	309	}
	310	};
311
312	template<int __i, typename _Tp, typename _Up>
313	struct __tuple_compare<0, __i, __i, _Tp, _Up>
314	{
315	static bool __eq(const _Tp&, const _Up&)
316	{ return true; }
317
318	static bool __less(const _Tp&, const _Up&)
319	{ return false; }
320	};
321
322	template<typename... _TElements, typename... _UElements>
323	bool
324	operator==(const tuple<_TElements...>& __t,
325	const tuple<_UElements...>& __u)
326	{
327	typedef tuple<_TElements...> _Tp;
328	typedef tuple<_UElements...> _Up;
230636fe	329	return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
894d0b15 CF	330	0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
	331	}
	332
	333	template<typename... _TElements, typename... _UElements>
	334	bool
	335	operator<(const tuple<_TElements...>& __t,
	336	const tuple<_UElements...>& __u)
	337	{
	338	typedef tuple<_TElements...> _Tp;
	339	typedef tuple<_UElements...> _Up;
230636fe	340	return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
894d0b15 CF	341	0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
	342	}
	343
	344	template<typename... _TElements, typename... _UElements>
	345	inline bool
	346	operator!=(const tuple<_TElements...>& __t,
	347	const tuple<_UElements...>& __u)
	348	{ return !(__t == __u); }
	349
	350	template<typename... _TElements, typename... _UElements>
	351	inline bool
	352	operator>(const tuple<_TElements...>& __t,
	353	const tuple<_UElements...>& __u)
	354	{ return __u < __t; }
	355
	356	template<typename... _TElements, typename... _UElements>
	357	inline bool
	358	operator<=(const tuple<_TElements...>& __t,
	359	const tuple<_UElements...>& __u)
	360	{ return !(__u < __t); }
	361
	362	template<typename... _TElements, typename... _UElements>
	363	inline bool
	364	operator>=(const tuple<_TElements...>& __t,
	365	const tuple<_UElements...>& __u)
	366	{ return !(__t < __u); }
	367
	368	template<typename _Tp>
	369	class reference_wrapper;
	370
	371	// Helper which adds a reference to a type when given a reference_wrapper
	372	template<typename _Tp>
	373	struct __strip_reference_wrapper
	374	{
	375	typedef _Tp __type;
	376	};
	377
	378	template<typename _Tp>
	379	struct __strip_reference_wrapper<reference_wrapper<_Tp> >
	380	{
	381	typedef _Tp& __type;
	382	};
	383
	384	template<typename _Tp>
	385	struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
	386	{
	387	typedef _Tp& __type;
	388	};
	389
	390	template<typename... _Elements>
	391	inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
	392	make_tuple(_Elements... __args)
	393	{
	394	typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
	395	__result_type;
	396	return __result_type(__args...);
	397	}
	398
	399	template<typename... _Elements>
	400	inline tuple<_Elements&...>
	401	tie(_Elements&... __args)
	402	{
	403	return tuple<_Elements&...>(__args...);
	404	}
405
406	// A class (and instance) which can be used in 'tie' when an element
407	// of a tuple is not required
408	struct _Swallow_assign
409	{
410	template<class _Tp>
411	_Swallow_assign&
412	operator=(const _Tp&)
413	{ return *this; }
414	};
415
416	// TODO: Put this in some kind of shared file.
417	namespace
418	{
419	_Swallow_assign ignore;
420	}; // anonymous namespace
4a15d842	421	}
12ffa228 BK	422
12ffa228 BK	423	_GLIBCXX_END_NAMESPACE_VERSION
894d0b15	424	}
e133ace8 PC	425
e133ace8 PC	426	#endif // _GLIBCXX_TR1_TUPLE