1// class template tuple -*- C++ -*-
2
3// Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
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
8// Free Software Foundation; either version 2, or (at your option)
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
16// You should have received a copy of the GNU General Public License along
17// with this library; see the file COPYING.  If not, write to the Free
18// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19// USA.
20
21// As a special exception, you may use this file as part of a free software
22// library without restriction.  Specifically, if other files instantiate
23// templates or use macros or inline functions from this file, or you compile
24// this file and link it with other files to produce an executable, this
25// file does not by itself cause the resulting executable to be covered by
26// the GNU General Public License.  This exception does not however
27// invalidate any other reasons why the executable file might be covered by
28// the GNU General Public License.
29
30/** @file tr1/tuple_iterate.h
31 *  This is an internal header file, included by other library headers.
32 *  You should not attempt to use it directly.
33 */
34
35// Chris Jefferson <chris@bubblescope.net>
36
37namespace std
38{
39_GLIBCXX_BEGIN_NAMESPACE(tr1)
40
41/// @brief class tuple_size
42template<_GLIBCXX_TEMPLATE_PARAMS>
43  struct tuple_size<tuple<_GLIBCXX_TEMPLATE_ARGS> >
44  { static const int value = _GLIBCXX_NUM_ARGS; };
45
46#if _GLIBCXX_NUM_ARGS > 0
47template<_GLIBCXX_TEMPLATE_PARAMS>
48  const int tuple_size<tuple<_GLIBCXX_TEMPLATE_ARGS> >::value;
49#endif
50
51template<_GLIBCXX_TEMPLATE_PARAMS>
52#ifdef _GLIBCXX_LAST_INCLUDE
53  class tuple
54#else
55  class tuple<_GLIBCXX_TEMPLATE_ARGS>
56#endif
57  {
58    _GLIBCXX_BIND_MEMBERS
59
60  public:
61    tuple()
62    { }
63
64#if _GLIBCXX_NUM_ARGS == 2
65    template<typename _U1, typename _U2>
66      tuple(const std::pair<_U1, _U2>& __u) :
67      _M_arg1(__u.first), _M_arg2(__u.second)
68      { }
69
70    template<typename _U1, typename _U2>
71      tuple&
72      operator=(const std::pair<_U1, _U2>& __u)
73      {
74	_M_arg1 = __u.first;
75	_M_arg2 = __u.second;
76	return *this;
77      }
78#endif
79
80#if _GLIBCXX_NUM_ARGS > 0
81    explicit tuple(_GLIBCXX_TUPLE_ADD_CREF) :
82      _GLIBCXX_BIND_MEMBERS_INIT
83    { }
84
85    template<_GLIBCXX_TEMPLATE_PARAMS_U>
86      tuple(const tuple<_GLIBCXX_TEMPLATE_ARGS_U>& __in) :
87      _GLIBCXX_TUPLE_COPY_INIT
88    { }
89
90
91    template<_GLIBCXX_TEMPLATE_PARAMS_U>
92      tuple&
93      operator=(const tuple<_GLIBCXX_TEMPLATE_ARGS_U>& __in)
94      {
95        _GLIBCXX_TUPLE_ASSIGN
96        return *this;
97      }
98
99    tuple(const tuple& __in) :
100      _GLIBCXX_TUPLE_COPY_INIT
101    { }
102
103#else
104
105    tuple(const tuple&)
106    { }
107
108#endif
109
110    tuple&
111    operator=(const tuple& __in __attribute__((__unused__)) )
112    {
113      _GLIBCXX_TUPLE_ASSIGN
114        return *this;
115    }
116
117    template<int __i, typename __Type>
118      friend class __get_helper;
119
120    template<_GLIBCXX_TUPLE_ALL_TEMPLATE_PARAMS_UNNAMED>
121      friend class tuple;
122  };
123
124#ifndef _GLIBCXX_LAST_INCLUDE
125
126template<typename _Tp>
127    struct __get_helper<_GLIBCXX_NUM_ARGS, _Tp>
128    {
129      static typename __add_ref<typename tuple_element<_GLIBCXX_NUM_ARGS,
130                                                       _Tp>::type>::type
131      get_value(_Tp& __in)
132      { return __in._GLIBCXX_CAT(_M_arg,_GLIBCXX_NUM_ARGS_PLUS_1); }
133
134      static typename __add_c_ref<typename tuple_element<_GLIBCXX_NUM_ARGS,
135                                                         _Tp>::type>::type
136      get_value(const _Tp& __in)
137      { return __in._GLIBCXX_CAT(_M_arg,_GLIBCXX_NUM_ARGS_PLUS_1); }
138    };
139
140/// @brief class tuple_element
141template<_GLIBCXX_TUPLE_ALL_TEMPLATE_PARAMS>
142   struct tuple_element<_GLIBCXX_NUM_ARGS, tuple<_GLIBCXX_TUPLE_ALL_TEMPLATE_ARGS> >
143  { typedef _GLIBCXX_T_NUM_ARGS_PLUS_1 type; };
144
145#endif
146#if _GLIBCXX_NUM_ARGS == 0
147
148tuple<>
149inline make_tuple()
150{ return tuple<>(); }
151
152tuple<>
153inline tie()
154{ return tuple<>(); }
155#else
156
157template<_GLIBCXX_TEMPLATE_PARAMS>
158  typename __stripped_tuple_type<_GLIBCXX_TEMPLATE_ARGS>::__type
159  inline make_tuple(_GLIBCXX_PARAMS)
160  {
161    return typename __stripped_tuple_type<_GLIBCXX_TEMPLATE_ARGS>::
162      __type(_GLIBCXX_ARGS);
163  }
164
165template<_GLIBCXX_TEMPLATE_PARAMS>
166  tuple<_GLIBCXX_REF_TEMPLATE_ARGS>
167  inline tie(_GLIBCXX_REF_PARAMS)
168  { return make_tuple(_GLIBCXX_REF_WRAP_PARAMS); }
169#endif
170
171_GLIBCXX_END_NAMESPACE
172}
173