1 : // Pair implementation -*- C++ -*-
2 :
3 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 : // Free Software Foundation, Inc.
5 : //
6 : // This file is part of the GNU ISO C++ Library. This library is free
7 : // software; you can redistribute it and/or modify it under the
8 : // terms of the GNU General Public License as published by the
9 : // Free Software Foundation; either version 2, or (at your option)
10 : // any later version.
11 :
12 : // This library is distributed in the hope that it will be useful,
13 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : // GNU General Public License for more details.
16 :
17 : // You should have received a copy of the GNU General Public License along
18 : // with this library; see the file COPYING. If not, write to the Free
19 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 : // USA.
21 :
22 : // As a special exception, you may use this file as part of a free software
23 : // library without restriction. Specifically, if other files instantiate
24 : // templates or use macros or inline functions from this file, or you compile
25 : // this file and link it with other files to produce an executable, this
26 : // file does not by itself cause the resulting executable to be covered by
27 : // the GNU General Public License. This exception does not however
28 : // invalidate any other reasons why the executable file might be covered by
29 : // the GNU General Public License.
30 :
31 : /*
32 : *
33 : * Copyright (c) 1994
34 : * Hewlett-Packard Company
35 : *
36 : * Permission to use, copy, modify, distribute and sell this software
37 : * and its documentation for any purpose is hereby granted without fee,
38 : * provided that the above copyright notice appear in all copies and
39 : * that both that copyright notice and this permission notice appear
40 : * in supporting documentation. Hewlett-Packard Company makes no
41 : * representations about the suitability of this software for any
42 : * purpose. It is provided "as is" without express or implied warranty.
43 : *
44 : *
45 : * Copyright (c) 1996,1997
46 : * Silicon Graphics Computer Systems, Inc.
47 : *
48 : * Permission to use, copy, modify, distribute and sell this software
49 : * and its documentation for any purpose is hereby granted without fee,
50 : * provided that the above copyright notice appear in all copies and
51 : * that both that copyright notice and this permission notice appear
52 : * in supporting documentation. Silicon Graphics makes no
53 : * representations about the suitability of this software for any
54 : * purpose. It is provided "as is" without express or implied warranty.
55 : */
56 :
57 : /** @file stl_pair.h
58 : * This is an internal header file, included by other library headers.
59 : * You should not attempt to use it directly.
60 : */
61 :
62 : #ifndef _STL_PAIR_H
63 : #define _STL_PAIR_H 1
64 :
65 : #include <bits/stl_move.h> // for std::move / std::forward, std::decay, and
66 : // std::swap
67 :
68 : _GLIBCXX_BEGIN_NAMESPACE(std)
69 :
70 : /// pair holds two objects of arbitrary type.
71 : template<class _T1, class _T2>
72 : struct pair
73 814163 : {
74 : typedef _T1 first_type; ///< @c first_type is the first bound type
75 : typedef _T2 second_type; ///< @c second_type is the second bound type
76 :
77 : _T1 first; ///< @c first is a copy of the first object
78 : _T2 second; ///< @c second is a copy of the second object
79 :
80 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
81 : // 265. std::pair::pair() effects overly restrictive
82 : /** The default constructor creates @c first and @c second using their
83 : * respective default constructors. */
84 19 : pair()
85 19 : : first(), second() { }
86 :
87 : /** Two objects may be passed to a @c pair constructor to be copied. */
88 3562241 : pair(const _T1& __a, const _T2& __b)
89 3562241 : : first(__a), second(__b) { }
90 :
91 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
92 : template<class _U1, class _U2>
93 : pair(_U1&& __x, _U2&& __y)
94 : : first(std::forward<_U1>(__x)),
95 : second(std::forward<_U2>(__y)) { }
96 :
97 : pair(pair&& __p)
98 : : first(std::move(__p.first)),
99 : second(std::move(__p.second)) { }
100 : #endif
101 :
102 : /** There is also a templated copy ctor for the @c pair class itself. */
103 : template<class _U1, class _U2>
104 101375 : pair(const pair<_U1, _U2>& __p)
105 : : first(__p.first),
106 101375 : second(__p.second) { }
107 :
108 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
109 : template<class _U1, class _U2>
110 : pair(pair<_U1, _U2>&& __p)
111 : : first(std::move(__p.first)),
112 : second(std::move(__p.second)) { }
113 :
114 : // http://gcc.gnu.org/ml/libstdc++/2007-08/msg00052.html
115 : template<class _U1, class _Arg0, class... _Args>
116 : pair(_U1&& __x, _Arg0&& __arg0, _Args&&... __args)
117 : : first(std::forward<_U1>(__x)),
118 : second(std::forward<_Arg0>(__arg0),
119 : std::forward<_Args>(__args)...) { }
120 :
121 : pair&
122 : operator=(pair&& __p)
123 : {
124 : first = std::move(__p.first);
125 : second = std::move(__p.second);
126 : return *this;
127 : }
128 :
129 : template<class _U1, class _U2>
130 : pair&
131 : operator=(pair<_U1, _U2>&& __p)
132 : {
133 : first = std::move(__p.first);
134 : second = std::move(__p.second);
135 : return *this;
136 : }
137 :
138 : void
139 : swap(pair&& __p)
140 : {
141 : using std::swap;
142 : swap(first, __p.first);
143 : swap(second, __p.second);
144 : }
145 : #endif
146 : };
147 :
148 : /// Two pairs of the same type are equal iff their members are equal.
149 : template<class _T1, class _T2>
150 : inline bool
151 : operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
152 : { return __x.first == __y.first && __x.second == __y.second; }
153 :
154 : /// <http://gcc.gnu.org/onlinedocs/libstdc++/20_util/howto.html#pairlt>
155 : template<class _T1, class _T2>
156 : inline bool
157 : operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
158 : { return __x.first < __y.first
159 : || (!(__y.first < __x.first) && __x.second < __y.second); }
160 :
161 : /// Uses @c operator== to find the result.
162 : template<class _T1, class _T2>
163 : inline bool
164 : operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
165 : { return !(__x == __y); }
166 :
167 : /// Uses @c operator< to find the result.
168 : template<class _T1, class _T2>
169 : inline bool
170 : operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
171 : { return __y < __x; }
172 :
173 : /// Uses @c operator< to find the result.
174 : template<class _T1, class _T2>
175 : inline bool
176 : operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
177 : { return !(__y < __x); }
178 :
179 : /// Uses @c operator< to find the result.
180 : template<class _T1, class _T2>
181 : inline bool
182 : operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
183 : { return !(__x < __y); }
184 :
185 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
186 : /// See std::pair::swap().
187 : template<class _T1, class _T2>
188 : inline void
189 : swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
190 : { __x.swap(__y); }
191 :
192 : template<class _T1, class _T2>
193 : inline void
194 : swap(pair<_T1, _T2>&& __x, pair<_T1, _T2>& __y)
195 : { __x.swap(__y); }
196 :
197 : template<class _T1, class _T2>
198 : inline void
199 : swap(pair<_T1, _T2>& __x, pair<_T1, _T2>&& __y)
200 : { __x.swap(__y); }
201 : #endif
202 :
203 : /**
204 : * @brief A convenience wrapper for creating a pair from two objects.
205 : * @param x The first object.
206 : * @param y The second object.
207 : * @return A newly-constructed pair<> object of the appropriate type.
208 : *
209 : * The standard requires that the objects be passed by reference-to-const,
210 : * but LWG issue #181 says they should be passed by const value. We follow
211 : * the LWG by default.
212 : */
213 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
214 : // 181. make_pair() unintended behavior
215 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
216 : template<class _T1, class _T2>
217 : inline pair<_T1, _T2>
218 474889 : make_pair(_T1 __x, _T2 __y)
219 474889 : { return pair<_T1, _T2>(__x, __y); }
220 : #else
221 : template<typename _Tp>
222 : class reference_wrapper;
223 :
224 : // Helper which adds a reference to a type when given a reference_wrapper
225 : template<typename _Tp>
226 : struct __strip_reference_wrapper
227 : {
228 : typedef _Tp __type;
229 : };
230 :
231 : template<typename _Tp>
232 : struct __strip_reference_wrapper<reference_wrapper<_Tp> >
233 : {
234 : typedef _Tp& __type;
235 : };
236 :
237 : template<typename _Tp>
238 : struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
239 : {
240 : typedef _Tp& __type;
241 : };
242 :
243 : template<typename _Tp>
244 : struct __decay_and_strip
245 : {
246 : typedef typename __strip_reference_wrapper<
247 : typename decay<_Tp>::type>::__type __type;
248 : };
249 :
250 : // NB: DR 706.
251 : template<class _T1, class _T2>
252 : inline pair<typename __decay_and_strip<_T1>::__type,
253 : typename __decay_and_strip<_T2>::__type>
254 : make_pair(_T1&& __x, _T2&& __y)
255 : {
256 : return pair<typename __decay_and_strip<_T1>::__type,
257 : typename __decay_and_strip<_T2>::__type>
258 : (std::forward<_T1>(__x), std::forward<_T2>(__y));
259 : }
260 : #endif
261 :
262 : _GLIBCXX_END_NAMESPACE
263 :
264 : #endif /* _STL_PAIR_H */
|
