Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / detail / compressed_pair.hpp
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 namespace boost
31 {
32
33 template <class T1, class T2>
34 class compressed_pair;
35
36
37 // compressed_pair
38
39 namespace details
40 {
41    // JM altered 26 Jan 2000:
42    template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
43    struct compressed_pair_switch;
44
45    template <class T1, class T2>
46    struct compressed_pair_switch<T1, T2, false, false, false>
47       {static const int value = 0;};
48
49    template <class T1, class T2>
50    struct compressed_pair_switch<T1, T2, false, true, true>
51       {static const int value = 3;};
52
53    template <class T1, class T2>
54    struct compressed_pair_switch<T1, T2, false, true, false>
55       {static const int value = 1;};
56
57    template <class T1, class T2>
58    struct compressed_pair_switch<T1, T2, false, false, true>
59       {static const int value = 2;};
60
61    template <class T1, class T2>
62    struct compressed_pair_switch<T1, T2, true, true, true>
63       {static const int value = 4;};
64
65    template <class T1, class T2>
66    struct compressed_pair_switch<T1, T2, true, false, false>
67       {static const int value = 5;};
68
69    template <class T1, class T2, int Version> class compressed_pair_imp;
70
71 #ifdef __GNUC__
72    // workaround for GCC (JM):
73    using std::swap;
74 #endif
75    //
76    // can't call unqualified swap from within classname::swap
77    // as Koenig lookup rules will find only the classname::swap
78    // member function not the global declaration, so use cp_swap
79    // as a forwarding function (JM):
80    template <typename T>
81    inline void cp_swap(T& t1, T& t2)
82    {
83 #ifndef __GNUC__
84       using std::swap;
85 #endif
86       swap(t1, t2);
87    }
88
89    // 0    derive from neither
90
91    template <class T1, class T2>
92    class compressed_pair_imp<T1, T2, 0>
93    {
94    public:
95       typedef T1                                                 first_type;
96       typedef T2                                                 second_type;
97       typedef typename call_traits<first_type>::param_type       first_param_type;
98       typedef typename call_traits<second_type>::param_type      second_param_type;
99       typedef typename call_traits<first_type>::reference        first_reference;
100       typedef typename call_traits<second_type>::reference       second_reference;
101       typedef typename call_traits<first_type>::const_reference  first_const_reference;
102       typedef typename call_traits<second_type>::const_reference second_const_reference;
103
104       compressed_pair_imp() {} 
105
106       compressed_pair_imp(first_param_type x, second_param_type y)
107          : first_(x), second_(y) {}
108
109       compressed_pair_imp(first_param_type x)
110          : first_(x) {}
111
112       compressed_pair_imp(second_param_type y)
113          : second_(y) {}
114
115       first_reference       first()       {return first_;}
116       first_const_reference first() const {return first_;}
117
118       second_reference       second()       {return second_;}
119       second_const_reference second() const {return second_;}
120
121       void swap(::boost::compressed_pair<T1, T2>& y)
122       {
123          cp_swap(first_, y.first());
124          cp_swap(second_, y.second());
125       }
126    private:
127       first_type first_;
128       second_type second_;
129    };
130
131    // 1    derive from T1
132
133    template <class T1, class T2>
134    class compressed_pair_imp<T1, T2, 1>
135       : private ::boost::remove_cv<T1>::type
136    {
137    public:
138       typedef T1                                                 first_type;
139       typedef T2                                                 second_type;
140       typedef typename call_traits<first_type>::param_type       first_param_type;
141       typedef typename call_traits<second_type>::param_type      second_param_type;
142       typedef typename call_traits<first_type>::reference        first_reference;
143       typedef typename call_traits<second_type>::reference       second_reference;
144       typedef typename call_traits<first_type>::const_reference  first_const_reference;
145       typedef typename call_traits<second_type>::const_reference second_const_reference;
146
147       compressed_pair_imp() {}
148
149       compressed_pair_imp(first_param_type x, second_param_type y)
150          : first_type(x), second_(y) {}
151
152       compressed_pair_imp(first_param_type x)
153          : first_type(x) {}
154
155       compressed_pair_imp(second_param_type y)
156          : second_(y) {}
157
158       first_reference       first()       {return *this;}
159       first_const_reference first() const {return *this;}
160
161       second_reference       second()       {return second_;}
162       second_const_reference second() const {return second_;}
163
164       void swap(::boost::compressed_pair<T1,T2>& y)
165       {
166          // no need to swap empty base class:
167          cp_swap(second_, y.second());
168       }
169    private:
170       second_type second_;
171    };
172
173    // 2    derive from T2
174
175    template <class T1, class T2>
176    class compressed_pair_imp<T1, T2, 2>
177       : private ::boost::remove_cv<T2>::type
178    {
179    public:
180       typedef T1                                                 first_type;
181       typedef T2                                                 second_type;
182       typedef typename call_traits<first_type>::param_type       first_param_type;
183       typedef typename call_traits<second_type>::param_type      second_param_type;
184       typedef typename call_traits<first_type>::reference        first_reference;
185       typedef typename call_traits<second_type>::reference       second_reference;
186       typedef typename call_traits<first_type>::const_reference  first_const_reference;
187       typedef typename call_traits<second_type>::const_reference second_const_reference;
188
189       compressed_pair_imp() {}
190
191       compressed_pair_imp(first_param_type x, second_param_type y)
192          : second_type(y), first_(x) {}
193
194       compressed_pair_imp(first_param_type x)
195          : first_(x) {}
196
197       compressed_pair_imp(second_param_type y)
198          : second_type(y) {}
199
200       first_reference       first()       {return first_;}
201       first_const_reference first() const {return first_;}
202
203       second_reference       second()       {return *this;}
204       second_const_reference second() const {return *this;}
205
206       void swap(::boost::compressed_pair<T1,T2>& y)
207       {
208          // no need to swap empty base class:
209          cp_swap(first_, y.first());
210       }
211
212    private:
213       first_type first_;
214    };
215
216    // 3    derive from T1 and T2
217
218    template <class T1, class T2>
219    class compressed_pair_imp<T1, T2, 3>
220       : private ::boost::remove_cv<T1>::type,
221         private ::boost::remove_cv<T2>::type
222    {
223    public:
224       typedef T1                                                 first_type;
225       typedef T2                                                 second_type;
226       typedef typename call_traits<first_type>::param_type       first_param_type;
227       typedef typename call_traits<second_type>::param_type      second_param_type;
228       typedef typename call_traits<first_type>::reference        first_reference;
229       typedef typename call_traits<second_type>::reference       second_reference;
230       typedef typename call_traits<first_type>::const_reference  first_const_reference;
231       typedef typename call_traits<second_type>::const_reference second_const_reference;
232
233       compressed_pair_imp() {}
234
235       compressed_pair_imp(first_param_type x, second_param_type y)
236          : first_type(x), second_type(y) {}
237
238       compressed_pair_imp(first_param_type x)
239          : first_type(x) {}
240
241       compressed_pair_imp(second_param_type y)
242          : second_type(y) {}
243
244       first_reference       first()       {return *this;}
245       first_const_reference first() const {return *this;}
246
247       second_reference       second()       {return *this;}
248       second_const_reference second() const {return *this;}
249       //
250       // no need to swap empty bases:
251       void swap(::boost::compressed_pair<T1,T2>&) {}
252    };
253
254    // JM
255    // 4    T1 == T2, T1 and T2 both empty
256    //      Note does not actually store an instance of T2 at all -
257    //      but reuses T1 base class for both first() and second().
258    template <class T1, class T2>
259    class compressed_pair_imp<T1, T2, 4>
260       : private ::boost::remove_cv<T1>::type
261    {
262    public:
263       typedef T1                                                 first_type;
264       typedef T2                                                 second_type;
265       typedef typename call_traits<first_type>::param_type       first_param_type;
266       typedef typename call_traits<second_type>::param_type      second_param_type;
267       typedef typename call_traits<first_type>::reference        first_reference;
268       typedef typename call_traits<second_type>::reference       second_reference;
269       typedef typename call_traits<first_type>::const_reference  first_const_reference;
270       typedef typename call_traits<second_type>::const_reference second_const_reference;
271
272       compressed_pair_imp() {}
273
274       compressed_pair_imp(first_param_type x, second_param_type y)
275          : first_type(x), m_second(y) {}
276
277       compressed_pair_imp(first_param_type x)
278          : first_type(x), m_second(x) {}
279
280       first_reference       first()       {return *this;}
281       first_const_reference first() const {return *this;}
282
283       second_reference       second()       {return m_second;}
284       second_const_reference second() const {return m_second;}
285
286       void swap(::boost::compressed_pair<T1,T2>&) {}
287    private:
288       T2 m_second;
289    };
290
291    // 5    T1 == T2 and are not empty:   //JM
292
293    template <class T1, class T2>
294    class compressed_pair_imp<T1, T2, 5>
295    {
296    public:
297       typedef T1                                                 first_type;
298       typedef T2                                                 second_type;
299       typedef typename call_traits<first_type>::param_type       first_param_type;
300       typedef typename call_traits<second_type>::param_type      second_param_type;
301       typedef typename call_traits<first_type>::reference        first_reference;
302       typedef typename call_traits<second_type>::reference       second_reference;
303       typedef typename call_traits<first_type>::const_reference  first_const_reference;
304       typedef typename call_traits<second_type>::const_reference second_const_reference;
305
306       compressed_pair_imp() {}
307
308       compressed_pair_imp(first_param_type x, second_param_type y)
309          : first_(x), second_(y) {}
310
311       compressed_pair_imp(first_param_type x)
312          : first_(x), second_(x) {}
313
314       first_reference       first()       {return first_;}
315       first_const_reference first() const {return first_;}
316
317       second_reference       second()       {return second_;}
318       second_const_reference second() const {return second_;}
319
320       void swap(::boost::compressed_pair<T1, T2>& y)
321       {
322          cp_swap(first_, y.first());
323          cp_swap(second_, y.second());
324       }
325    private:
326       first_type first_;
327       second_type second_;
328    };
329
330 }  // details
331
332 template <class T1, class T2>
333 class compressed_pair
334    : private ::boost::details::compressed_pair_imp<T1, T2,
335              ::boost::details::compressed_pair_switch<
336                     T1,
337                     T2,
338                     ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
339                     ::boost::is_empty<T1>::value,
340                     ::boost::is_empty<T2>::value>::value>
341 {
342 private:
343    typedef details::compressed_pair_imp<T1, T2,
344              ::boost::details::compressed_pair_switch<
345                     T1,
346                     T2,
347                     ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
348                     ::boost::is_empty<T1>::value,
349                     ::boost::is_empty<T2>::value>::value> base;
350 public:
351    typedef T1                                                 first_type;
352    typedef T2                                                 second_type;
353    typedef typename call_traits<first_type>::param_type       first_param_type;
354    typedef typename call_traits<second_type>::param_type      second_param_type;
355    typedef typename call_traits<first_type>::reference        first_reference;
356    typedef typename call_traits<second_type>::reference       second_reference;
357    typedef typename call_traits<first_type>::const_reference  first_const_reference;
358    typedef typename call_traits<second_type>::const_reference second_const_reference;
359
360             compressed_pair() : base() {}
361             compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
362    explicit compressed_pair(first_param_type x) : base(x) {}
363    explicit compressed_pair(second_param_type y) : base(y) {}
364
365    first_reference       first()       {return base::first();}
366    first_const_reference first() const {return base::first();}
367
368    second_reference       second()       {return base::second();}
369    second_const_reference second() const {return base::second();}
370
371    void swap(compressed_pair& y) { base::swap(y); }
372 };
373
374 // JM
375 // Partial specialisation for case where T1 == T2:
376 //
377 template <class T>
378 class compressed_pair<T, T>
379    : private details::compressed_pair_imp<T, T,
380              ::boost::details::compressed_pair_switch<
381                     T,
382                     T,
383                     ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
384                     ::boost::is_empty<T>::value,
385                     ::boost::is_empty<T>::value>::value>
386 {
387 private:
388    typedef details::compressed_pair_imp<T, T,
389              ::boost::details::compressed_pair_switch<
390                     T,
391                     T,
392                     ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
393                     ::boost::is_empty<T>::value,
394                     ::boost::is_empty<T>::value>::value> base;
395 public:
396    typedef T                                                  first_type;
397    typedef T                                                  second_type;
398    typedef typename call_traits<first_type>::param_type       first_param_type;
399    typedef typename call_traits<second_type>::param_type      second_param_type;
400    typedef typename call_traits<first_type>::reference        first_reference;
401    typedef typename call_traits<second_type>::reference       second_reference;
402    typedef typename call_traits<first_type>::const_reference  first_const_reference;
403    typedef typename call_traits<second_type>::const_reference second_const_reference;
404
405             compressed_pair() : base() {}
406             compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
407 #if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
408    explicit 
409 #endif
410       compressed_pair(first_param_type x) : base(x) {}
411
412    first_reference       first()       {return base::first();}
413    first_const_reference first() const {return base::first();}
414
415    second_reference       second()       {return base::second();}
416    second_const_reference second() const {return base::second();}
417
418    void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
419 };
420
421 template <class T1, class T2>
422 inline
423 void
424 swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
425 {
426    x.swap(y);
427 }
428
429 } // boost
430
431 #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
432