Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/detail/compressed_pair.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children c530137014c0
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
1 // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
2 // Use, modification and distribution are subject to the Boost Software License,
3 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
4 // http://www.boost.org/LICENSE_1_0.txt).
5 //
6 // See http://www.boost.org/libs/utility for most recent version including documentation.
7
8 // compressed_pair: pair that "compresses" empty members
9 // (see libs/utility/compressed_pair.htm)
10 //
11 // JM changes 25 Jan 2004:
12 // For the case where T1 == T2 and both are empty, then first() and second()
13 // should return different objects.
14 // JM changes 25 Jan 2000:
15 // Removed default arguments from compressed_pair_switch to get
16 // C++ Builder 4 to accept them
17 // rewriten swap to get gcc and C++ builder to compile.
18 // added partial specialisations for case T1 == T2 to avoid duplicate constructor defs.
19
20 #ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP
21 #define BOOST_DETAIL_COMPRESSED_PAIR_HPP
22
23 #include <algorithm>
24
25 #include <boost/type_traits/remove_cv.hpp>
26 #include <boost/type_traits/is_empty.hpp>
27 #include <boost/type_traits/is_same.hpp>
28 #include <boost/call_traits.hpp>
29
30 #ifdef BOOST_MSVC
31 # pragma warning(push)
32 # pragma warning(disable:4512)
33 #endif
34 namespace boost
35 {
36
37 template <class T1, class T2>
38 class compressed_pair;
39
40
41 // compressed_pair
42
43 namespace details
44 {
45 // JM altered 26 Jan 2000:
46 template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
47 struct compressed_pair_switch;
48
49 template <class T1, class T2>
50 struct compressed_pair_switch<T1, T2, false, false, false>
51 {static const int value = 0;};
52
53 template <class T1, class T2>
54 struct compressed_pair_switch<T1, T2, false, true, true>
55 {static const int value = 3;};
56
57 template <class T1, class T2>
58 struct compressed_pair_switch<T1, T2, false, true, false>
59 {static const int value = 1;};
60
61 template <class T1, class T2>
62 struct compressed_pair_switch<T1, T2, false, false, true>
63 {static const int value = 2;};
64
65 template <class T1, class T2>
66 struct compressed_pair_switch<T1, T2, true, true, true>
67 {static const int value = 4;};
68
69 template <class T1, class T2>
70 struct compressed_pair_switch<T1, T2, true, false, false>
71 {static const int value = 5;};
72
73 template <class T1, class T2, int Version> class compressed_pair_imp;
74
75 #ifdef __GNUC__
76 // workaround for GCC (JM):
77 using std::swap;
78 #endif
79 //
80 // can't call unqualified swap from within classname::swap
81 // as Koenig lookup rules will find only the classname::swap
82 // member function not the global declaration, so use cp_swap
83 // as a forwarding function (JM):
84 template <typename T>
85 inline void cp_swap(T& t1, T& t2)
86 {
87 #ifndef __GNUC__
88 using std::swap;
89 #endif
90 swap(t1, t2);
91 }
92
93 // 0 derive from neither
94
95 template <class T1, class T2>
96 class compressed_pair_imp<T1, T2, 0>
97 {
98 public:
99 typedef T1 first_type;
100 typedef T2 second_type;
101 typedef typename call_traits<first_type>::param_type first_param_type;
102 typedef typename call_traits<second_type>::param_type second_param_type;
103 typedef typename call_traits<first_type>::reference first_reference;
104 typedef typename call_traits<second_type>::reference second_reference;
105 typedef typename call_traits<first_type>::const_reference first_const_reference;
106 typedef typename call_traits<second_type>::const_reference second_const_reference;
107
108 compressed_pair_imp() {}
109
110 compressed_pair_imp(first_param_type x, second_param_type y)
111 : first_(x), second_(y) {}
112
113 compressed_pair_imp(first_param_type x)
114 : first_(x) {}
115
116 compressed_pair_imp(second_param_type y)
117 : second_(y) {}
118
119 first_reference first() {return first_;}
120 first_const_reference first() const {return first_;}
121
122 second_reference second() {return second_;}
123 second_const_reference second() const {return second_;}
124
125 void swap(::boost::compressed_pair<T1, T2>& y)
126 {
127 cp_swap(first_, y.first());
128 cp_swap(second_, y.second());
129 }
130 private:
131 first_type first_;
132 second_type second_;
133 };
134
135 // 1 derive from T1
136
137 template <class T1, class T2>
138 class compressed_pair_imp<T1, T2, 1>
139 : protected ::boost::remove_cv<T1>::type
140 {
141 public:
142 typedef T1 first_type;
143 typedef T2 second_type;
144 typedef typename call_traits<first_type>::param_type first_param_type;
145 typedef typename call_traits<second_type>::param_type second_param_type;
146 typedef typename call_traits<first_type>::reference first_reference;
147 typedef typename call_traits<second_type>::reference second_reference;
148 typedef typename call_traits<first_type>::const_reference first_const_reference;
149 typedef typename call_traits<second_type>::const_reference second_const_reference;
150
151 compressed_pair_imp() {}
152
153 compressed_pair_imp(first_param_type x, second_param_type y)
154 : first_type(x), second_(y) {}
155
156 compressed_pair_imp(first_param_type x)
157 : first_type(x) {}
158
159 compressed_pair_imp(second_param_type y)
160 : second_(y) {}
161
162 first_reference first() {return *this;}
163 first_const_reference first() const {return *this;}
164
165 second_reference second() {return second_;}
166 second_const_reference second() const {return second_;}
167
168 void swap(::boost::compressed_pair<T1,T2>& y)
169 {
170 // no need to swap empty base class:
171 cp_swap(second_, y.second());
172 }
173 private:
174 second_type second_;
175 };
176
177 // 2 derive from T2
178
179 template <class T1, class T2>
180 class compressed_pair_imp<T1, T2, 2>
181 : protected ::boost::remove_cv<T2>::type
182 {
183 public:
184 typedef T1 first_type;
185 typedef T2 second_type;
186 typedef typename call_traits<first_type>::param_type first_param_type;
187 typedef typename call_traits<second_type>::param_type second_param_type;
188 typedef typename call_traits<first_type>::reference first_reference;
189 typedef typename call_traits<second_type>::reference second_reference;
190 typedef typename call_traits<first_type>::const_reference first_const_reference;
191 typedef typename call_traits<second_type>::const_reference second_const_reference;
192
193 compressed_pair_imp() {}
194
195 compressed_pair_imp(first_param_type x, second_param_type y)
196 : second_type(y), first_(x) {}
197
198 compressed_pair_imp(first_param_type x)
199 : first_(x) {}
200
201 compressed_pair_imp(second_param_type y)
202 : second_type(y) {}
203
204 first_reference first() {return first_;}
205 first_const_reference first() const {return first_;}
206
207 second_reference second() {return *this;}
208 second_const_reference second() const {return *this;}
209
210 void swap(::boost::compressed_pair<T1,T2>& y)
211 {
212 // no need to swap empty base class:
213 cp_swap(first_, y.first());
214 }
215
216 private:
217 first_type first_;
218 };
219
220 // 3 derive from T1 and T2
221
222 template <class T1, class T2>
223 class compressed_pair_imp<T1, T2, 3>
224 : protected ::boost::remove_cv<T1>::type,
225 protected ::boost::remove_cv<T2>::type
226 {
227 public:
228 typedef T1 first_type;
229 typedef T2 second_type;
230 typedef typename call_traits<first_type>::param_type first_param_type;
231 typedef typename call_traits<second_type>::param_type second_param_type;
232 typedef typename call_traits<first_type>::reference first_reference;
233 typedef typename call_traits<second_type>::reference second_reference;
234 typedef typename call_traits<first_type>::const_reference first_const_reference;
235 typedef typename call_traits<second_type>::const_reference second_const_reference;
236
237 compressed_pair_imp() {}
238
239 compressed_pair_imp(first_param_type x, second_param_type y)
240 : first_type(x), second_type(y) {}
241
242 compressed_pair_imp(first_param_type x)
243 : first_type(x) {}
244
245 compressed_pair_imp(second_param_type y)
246 : second_type(y) {}
247
248 first_reference first() {return *this;}
249 first_const_reference first() const {return *this;}
250
251 second_reference second() {return *this;}
252 second_const_reference second() const {return *this;}
253 //
254 // no need to swap empty bases:
255 void swap(::boost::compressed_pair<T1,T2>&) {}
256 };
257
258 // JM
259 // 4 T1 == T2, T1 and T2 both empty
260 // Originally this did not store an instance of T2 at all
261 // but that led to problems beause it meant &x.first() == &x.second()
262 // which is not true for any other kind of pair, so now we store an instance
263 // of T2 just in case the user is relying on first() and second() returning
264 // different objects (albeit both empty).
265 template <class T1, class T2>
266 class compressed_pair_imp<T1, T2, 4>
267 : protected ::boost::remove_cv<T1>::type
268 {
269 public:
270 typedef T1 first_type;
271 typedef T2 second_type;
272 typedef typename call_traits<first_type>::param_type first_param_type;
273 typedef typename call_traits<second_type>::param_type second_param_type;
274 typedef typename call_traits<first_type>::reference first_reference;
275 typedef typename call_traits<second_type>::reference second_reference;
276 typedef typename call_traits<first_type>::const_reference first_const_reference;
277 typedef typename call_traits<second_type>::const_reference second_const_reference;
278
279 compressed_pair_imp() {}
280
281 compressed_pair_imp(first_param_type x, second_param_type y)
282 : first_type(x), m_second(y) {}
283
284 compressed_pair_imp(first_param_type x)
285 : first_type(x), m_second(x) {}
286
287 first_reference first() {return *this;}
288 first_const_reference first() const {return *this;}
289
290 second_reference second() {return m_second;}
291 second_const_reference second() const {return m_second;}
292
293 void swap(::boost::compressed_pair<T1,T2>&) {}
294 private:
295 T2 m_second;
296 };
297
298 // 5 T1 == T2 and are not empty: //JM
299
300 template <class T1, class T2>
301 class compressed_pair_imp<T1, T2, 5>
302 {
303 public:
304 typedef T1 first_type;
305 typedef T2 second_type;
306 typedef typename call_traits<first_type>::param_type first_param_type;
307 typedef typename call_traits<second_type>::param_type second_param_type;
308 typedef typename call_traits<first_type>::reference first_reference;
309 typedef typename call_traits<second_type>::reference second_reference;
310 typedef typename call_traits<first_type>::const_reference first_const_reference;
311 typedef typename call_traits<second_type>::const_reference second_const_reference;
312
313 compressed_pair_imp() {}
314
315 compressed_pair_imp(first_param_type x, second_param_type y)
316 : first_(x), second_(y) {}
317
318 compressed_pair_imp(first_param_type x)
319 : first_(x), second_(x) {}
320
321 first_reference first() {return first_;}
322 first_const_reference first() const {return first_;}
323
324 second_reference second() {return second_;}
325 second_const_reference second() const {return second_;}
326
327 void swap(::boost::compressed_pair<T1, T2>& y)
328 {
329 cp_swap(first_, y.first());
330 cp_swap(second_, y.second());
331 }
332 private:
333 first_type first_;
334 second_type second_;
335 };
336
337 } // details
338
339 template <class T1, class T2>
340 class compressed_pair
341 : private ::boost::details::compressed_pair_imp<T1, T2,
342 ::boost::details::compressed_pair_switch<
343 T1,
344 T2,
345 ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
346 ::boost::is_empty<T1>::value,
347 ::boost::is_empty<T2>::value>::value>
348 {
349 private:
350 typedef details::compressed_pair_imp<T1, T2,
351 ::boost::details::compressed_pair_switch<
352 T1,
353 T2,
354 ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
355 ::boost::is_empty<T1>::value,
356 ::boost::is_empty<T2>::value>::value> base;
357 public:
358 typedef T1 first_type;
359 typedef T2 second_type;
360 typedef typename call_traits<first_type>::param_type first_param_type;
361 typedef typename call_traits<second_type>::param_type second_param_type;
362 typedef typename call_traits<first_type>::reference first_reference;
363 typedef typename call_traits<second_type>::reference second_reference;
364 typedef typename call_traits<first_type>::const_reference first_const_reference;
365 typedef typename call_traits<second_type>::const_reference second_const_reference;
366
367 compressed_pair() : base() {}
368 compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
369 explicit compressed_pair(first_param_type x) : base(x) {}
370 explicit compressed_pair(second_param_type y) : base(y) {}
371
372 first_reference first() {return base::first();}
373 first_const_reference first() const {return base::first();}
374
375 second_reference second() {return base::second();}
376 second_const_reference second() const {return base::second();}
377
378 void swap(compressed_pair& y) { base::swap(y); }
379 };
380
381 // JM
382 // Partial specialisation for case where T1 == T2:
383 //
384 template <class T>
385 class compressed_pair<T, T>
386 : private details::compressed_pair_imp<T, T,
387 ::boost::details::compressed_pair_switch<
388 T,
389 T,
390 ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
391 ::boost::is_empty<T>::value,
392 ::boost::is_empty<T>::value>::value>
393 {
394 private:
395 typedef details::compressed_pair_imp<T, T,
396 ::boost::details::compressed_pair_switch<
397 T,
398 T,
399 ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
400 ::boost::is_empty<T>::value,
401 ::boost::is_empty<T>::value>::value> base;
402 public:
403 typedef T first_type;
404 typedef T second_type;
405 typedef typename call_traits<first_type>::param_type first_param_type;
406 typedef typename call_traits<second_type>::param_type second_param_type;
407 typedef typename call_traits<first_type>::reference first_reference;
408 typedef typename call_traits<second_type>::reference second_reference;
409 typedef typename call_traits<first_type>::const_reference first_const_reference;
410 typedef typename call_traits<second_type>::const_reference second_const_reference;
411
412 compressed_pair() : base() {}
413 compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
414 #if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
415 explicit
416 #endif
417 compressed_pair(first_param_type x) : base(x) {}
418
419 first_reference first() {return base::first();}
420 first_const_reference first() const {return base::first();}
421
422 second_reference second() {return base::second();}
423 second_const_reference second() const {return base::second();}
424
425 void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
426 };
427
428 template <class T1, class T2>
429 inline
430 void
431 swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
432 {
433 x.swap(y);
434 }
435
436 } // boost
437
438 #ifdef BOOST_MSVC
439 # pragma warning(pop)
440 #endif
441
442 #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
443