[ceph.git] / ceph / src / boost / libs / utility / include / boost / detail / ob_compressed_pair.hpp

//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
//  Use, modification and distribution are subject to the Boost Software License,
//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt).
//
//  See http://www.boost.org/libs/utility for most recent version including documentation.
//  see libs/utility/compressed_pair.hpp
//
/* Release notes:
   20 Jan 2001:
        Fixed obvious bugs (David Abrahams)
   07 Oct 2000:
      Added better single argument constructor support.
   03 Oct 2000:
      Added VC6 support (JM).
   23rd July 2000:
      Additional comments added. (JM)
   Jan 2000:
      Original version: this version crippled for use with crippled compilers
      - John Maddock Jan 2000.
*/


#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
#define BOOST_OB_COMPRESSED_PAIR_HPP

#include <algorithm>
#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
#include <boost/type_traits/object_traits.hpp>
#endif
#ifndef BOOST_SAME_TRAITS_HPP
#include <boost/type_traits/same_traits.hpp>
#endif
#ifndef BOOST_CALL_TRAITS_HPP
#include <boost/call_traits.hpp>
#endif

namespace boost
{
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
//
// use member templates to emulate
// partial specialisation.  Note that due to
// problems with overload resolution with VC6
// each of the compressed_pair versions that follow
// have one template single-argument constructor
// in place of two specific constructors:
//

template <class T1, class T2>
class compressed_pair;

namespace detail{

template <class A, class T1, class T2>
struct best_conversion_traits
{
   typedef char one;
   typedef char (&two)[2];
   static A a;
   static one test(T1);
   static two test(T2);

   enum { value = sizeof(test(a)) };
};

template <int>
struct init_one;

template <>
struct init_one<1>
{
   template <class A, class T1, class T2>
   static void init(const A& a, T1* p1, T2*)
   {
      *p1 = a;
   }
};

template <>
struct init_one<2>
{
   template <class A, class T1, class T2>
   static void init(const A& a, T1*, T2* p2)
   {
      *p2 = a;
   }
};


// T1 != T2, both non-empty
template <class T1, class T2>
class compressed_pair_0
{
private:
   T1 _first;
   T2 _second;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_0() : _first(), _second() {}
            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   template <class A>
   explicit compressed_pair_0(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
   }
   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
      : _first(x.first()), _second(x.second()) {}

#if 0
  compressed_pair_0& operator=(const compressed_pair_0& x) {
    cout << "assigning compressed pair 0" << endl;
    _first = x._first;
    _second = x._second;
    cout << "finished assigning compressed pair 0" << endl;
    return *this;
  }
#endif

   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }

   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }

   void swap(compressed_pair_0& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
};

// T1 != T2, T2 empty
template <class T1, class T2>
class compressed_pair_1 : T2
{
private:
   T1 _first;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_1() : T2(), _first() {}
            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}

   template <class A>
   explicit compressed_pair_1(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
   }

   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
      : T2(x.second()), _first(x.first()) {}

   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }

   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }

   void swap(compressed_pair_1& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_first, y._first);
   }
};

// T1 != T2, T1 empty
template <class T1, class T2>
class compressed_pair_2 : T1
{
private:
   T2 _second;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_2() : T1(), _second() {}
            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
   template <class A>
   explicit compressed_pair_2(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
   }
   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x.first()), _second(x.second()) {}

#if 0
  compressed_pair_2& operator=(const compressed_pair_2& x) {
    cout << "assigning compressed pair 2" << endl;
    T1::operator=(x);
    _second = x._second;
    cout << "finished assigning compressed pair 2" << endl;
    return *this;
  }
#endif
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }

   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }

   void swap(compressed_pair_2& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_second, y._second);
   }
};

// T1 != T2, both empty
template <class T1, class T2>
class compressed_pair_3 : T1, T2
{
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_3() : T1(), T2() {}
            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
   template <class A>
   explicit compressed_pair_3(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
   }
   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x.first()), T2(x.second()) {}

   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }

   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }

   void swap(compressed_pair_3& y)
   {
      // no need to swap empty base classes:
   }
};

// T1 == T2, and empty
template <class T1, class T2>
class compressed_pair_4 : T1
{
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_4() : T1() {}
            compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
   // only one single argument constructor since T1 == T2
   explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
   compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x.first()), m_second(x.second()) {}

   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }

   second_reference       second()       { return m_second; }
   second_const_reference second() const { return m_second; }

   void swap(compressed_pair_4& y)
   {
      // no need to swap empty base classes:
   }
private:
   T2 m_second;
};

// T1 == T2, not empty
template <class T1, class T2>
class compressed_pair_5
{
private:
   T1 _first;
   T2 _second;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair_5() : _first(), _second() {}
            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   // only one single argument constructor since T1 == T2
   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
      : _first(c.first()), _second(c.second()) {}

   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }

   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }

   void swap(compressed_pair_5& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
};

template <bool e1, bool e2, bool same>
struct compressed_pair_chooser
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_0<T1, T2> type;
   };
};

template <>
struct compressed_pair_chooser<false, true, false>
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_1<T1, T2> type;
   };
};

template <>
struct compressed_pair_chooser<true, false, false>
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_2<T1, T2> type;
   };
};

template <>
struct compressed_pair_chooser<true, true, false>
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_3<T1, T2> type;
   };
};

template <>
struct compressed_pair_chooser<true, true, true>
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_4<T1, T2> type;
   };
};

template <>
struct compressed_pair_chooser<false, false, true>
{
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_5<T1, T2> type;
   };
};

template <class T1, class T2>
struct compressed_pair_traits
{
private:
   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
   typedef typename chooser::template rebind<T1, T2> bound_type;
public:
   typedef typename bound_type::type type;
};

} // namespace detail

template <class T1, class T2>
class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
{
private:
   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair() : base_type() {}
            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
   template <class A>
   explicit compressed_pair(const A& x) : base_type(x){}

   first_reference       first()       { return base_type::first(); }
   first_const_reference first() const { return base_type::first(); }

   second_reference       second()       { return base_type::second(); }
   second_const_reference second() const { return base_type::second(); }
};

template <class T1, class T2>
inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
{
   x.swap(y);
}

#else
// no partial specialisation, no member templates:

template <class T1, class T2>
class compressed_pair
{
private:
   T1 _first;
   T2 _second;
public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;

            compressed_pair() : _first(), _second() {}
            compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   explicit compressed_pair(first_param_type x) : _first(x), _second() {}
   // can't define this in case T1 == T2:
   // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}

   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }

   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }

   void swap(compressed_pair& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
};

template <class T1, class T2>
inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
{
   x.swap(y);
}

#endif

} // boost

#endif // BOOST_OB_COMPRESSED_PAIR_HPP
Commit	Line	Data
7c673cae FG	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	// see libs/utility/compressed_pair.hpp
	8	//
	9	/* Release notes:
	10	20 Jan 2001:
	11	Fixed obvious bugs (David Abrahams)
	12	07 Oct 2000:
	13	Added better single argument constructor support.
	14	03 Oct 2000:
	15	Added VC6 support (JM).
	16	23rd July 2000:
	17	Additional comments added. (JM)
	18	Jan 2000:
	19	Original version: this version crippled for use with crippled compilers
	20	- John Maddock Jan 2000.
	21	*/
	22
	23
	24	#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
	25	#define BOOST_OB_COMPRESSED_PAIR_HPP
	26
	27	#include <algorithm>
	28	#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
	29	#include <boost/type_traits/object_traits.hpp>
	30	#endif
	31	#ifndef BOOST_SAME_TRAITS_HPP
	32	#include <boost/type_traits/same_traits.hpp>
	33	#endif
	34	#ifndef BOOST_CALL_TRAITS_HPP
	35	#include <boost/call_traits.hpp>
	36	#endif
	37
	38	namespace boost
	39	{
	40	#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
	41	//
	42	// use member templates to emulate
	43	// partial specialisation. Note that due to
	44	// problems with overload resolution with VC6
	45	// each of the compressed_pair versions that follow
	46	// have one template single-argument constructor
	47	// in place of two specific constructors:
	48	//
	49
	50	template <class T1, class T2>
	51	class compressed_pair;
	52
	53	namespace detail{
	54
	55	template <class A, class T1, class T2>
	56	struct best_conversion_traits
	57	{
	58	typedef char one;
	59	typedef char (&two)[2];
	60	static A a;
	61	static one test(T1);
	62	static two test(T2);
	63
	64	enum { value = sizeof(test(a)) };
65	};
66
67	template <int>
68	struct init_one;
69
70	template <>
71	struct init_one<1>
72	{
73	template <class A, class T1, class T2>
74	static void init(const A& a, T1* p1, T2*)
75	{
76	*p1 = a;
77	}
78	};
79
80	template <>
81	struct init_one<2>
82	{
83	template <class A, class T1, class T2>
84	static void init(const A& a, T1, T2 p2)
85	{
86	*p2 = a;
87	}
88	};
89
90
91	// T1 != T2, both non-empty
92	template <class T1, class T2>
93	class compressed_pair_0
94	{
95	private:
96	T1 _first;
97	T2 _second;
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_0() : _first(), _second() {}
109	compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
110	template <class A>
111	explicit compressed_pair_0(const A& val)
112	{
113	init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
114	}
115	compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
116	: _first(x.first()), _second(x.second()) {}
117
118	#if 0
119	compressed_pair_0& operator=(const compressed_pair_0& x) {
120	cout << "assigning compressed pair 0" << endl;
121	_first = x._first;
122	_second = x._second;
123	cout << "finished assigning compressed pair 0" << endl;
124	return *this;
125	}
126	#endif
127
128	first_reference first() { return _first; }
129	first_const_reference first() const { return _first; }
130
131	second_reference second() { return _second; }
132	second_const_reference second() const { return _second; }
133
134	void swap(compressed_pair_0& y)
135	{
136	using std::swap;
137	swap(_first, y._first);
138	swap(_second, y._second);
139	}
140	};
141
142	// T1 != T2, T2 empty
143	template <class T1, class T2>
144	class compressed_pair_1 : T2
145	{
146	private:
147	T1 _first;
148	public:
149	typedef T1 first_type;
150	typedef T2 second_type;
151	typedef typename call_traits<first_type>::param_type first_param_type;
152	typedef typename call_traits<second_type>::param_type second_param_type;
153	typedef typename call_traits<first_type>::reference first_reference;
154	typedef typename call_traits<second_type>::reference second_reference;
155	typedef typename call_traits<first_type>::const_reference first_const_reference;
156	typedef typename call_traits<second_type>::const_reference second_const_reference;
157
158	compressed_pair_1() : T2(), _first() {}
159	compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
160
161	template <class A>
162	explicit compressed_pair_1(const A& val)
163	{
164	init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
165	}
166
167	compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
168	: T2(x.second()), _first(x.first()) {}
169
170	first_reference first() { return _first; }
171	first_const_reference first() const { return _first; }
172
173	second_reference second() { return *this; }
174	second_const_reference second() const { return *this; }
175
176	void swap(compressed_pair_1& y)
177	{
178	// no need to swap empty base class:
179	using std::swap;
180	swap(_first, y._first);
181	}
182	};
183
184	// T1 != T2, T1 empty
185	template <class T1, class T2>
186	class compressed_pair_2 : T1
187	{
188	private:
189	T2 _second;
190	public:
191	typedef T1 first_type;
192	typedef T2 second_type;
193	typedef typename call_traits<first_type>::param_type first_param_type;
194	typedef typename call_traits<second_type>::param_type second_param_type;
195	typedef typename call_traits<first_type>::reference first_reference;
196	typedef typename call_traits<second_type>::reference second_reference;
197	typedef typename call_traits<first_type>::const_reference first_const_reference;
198	typedef typename call_traits<second_type>::const_reference second_const_reference;
199
200	compressed_pair_2() : T1(), _second() {}
201	compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
202	template <class A>
203	explicit compressed_pair_2(const A& val)
204	{
205	init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
206	}
207	compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
208	: T1(x.first()), _second(x.second()) {}
209
210	#if 0
211	compressed_pair_2& operator=(const compressed_pair_2& x) {
212	cout << "assigning compressed pair 2" << endl;
213	T1::operator=(x);
214	_second = x._second;
215	cout << "finished assigning compressed pair 2" << endl;
216	return *this;
217	}
218	#endif
219	first_reference first() { return *this; }
220	first_const_reference first() const { return *this; }
221
222	second_reference second() { return _second; }
223	second_const_reference second() const { return _second; }
224
225	void swap(compressed_pair_2& y)
226	{
227	// no need to swap empty base class:
228	using std::swap;
229	swap(_second, y._second);
230	}
231	};
232
233	// T1 != T2, both empty
234	template <class T1, class T2>
235	class compressed_pair_3 : T1, T2
236	{
237	public:
238	typedef T1 first_type;
239	typedef T2 second_type;
240	typedef typename call_traits<first_type>::param_type first_param_type;
241	typedef typename call_traits<second_type>::param_type second_param_type;
242	typedef typename call_traits<first_type>::reference first_reference;
243	typedef typename call_traits<second_type>::reference second_reference;
244	typedef typename call_traits<first_type>::const_reference first_const_reference;
245	typedef typename call_traits<second_type>::const_reference second_const_reference;
246
247	compressed_pair_3() : T1(), T2() {}
248	compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
249	template <class A>
250	explicit compressed_pair_3(const A& val)
251	{
252	init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1>(this), static_cast<T2>(this));
253	}
254	compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
255	: T1(x.first()), T2(x.second()) {}
256
257	first_reference first() { return *this; }
258	first_const_reference first() const { return *this; }
259
260	second_reference second() { return *this; }
261	second_const_reference second() const { return *this; }
262
263	void swap(compressed_pair_3& y)
264	{
265	// no need to swap empty base classes:
266	}
267	};
268
269	// T1 == T2, and empty
270	template <class T1, class T2>
271	class compressed_pair_4 : T1
272	{
273	public:
274	typedef T1 first_type;
275	typedef T2 second_type;
276	typedef typename call_traits<first_type>::param_type first_param_type;
277	typedef typename call_traits<second_type>::param_type second_param_type;
278	typedef typename call_traits<first_type>::reference first_reference;
279	typedef typename call_traits<second_type>::reference second_reference;
280	typedef typename call_traits<first_type>::const_reference first_const_reference;
281	typedef typename call_traits<second_type>::const_reference second_const_reference;
282
283	compressed_pair_4() : T1() {}
284	compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
285	// only one single argument constructor since T1 == T2
286	explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
287	compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
288	: T1(x.first()), m_second(x.second()) {}
289
290	first_reference first() { return *this; }
291	first_const_reference first() const { return *this; }
292
293	second_reference second() { return m_second; }
294	second_const_reference second() const { return m_second; }
295
296	void swap(compressed_pair_4& y)
297	{
298	// no need to swap empty base classes:
299	}
300	private:
301	T2 m_second;
302	};
303
304	// T1 == T2, not empty
305	template <class T1, class T2>
306	class compressed_pair_5
307	{
308	private:
309	T1 _first;
310	T2 _second;
311	public:
312	typedef T1 first_type;
313	typedef T2 second_type;
314	typedef typename call_traits<first_type>::param_type first_param_type;
315	typedef typename call_traits<second_type>::param_type second_param_type;
316	typedef typename call_traits<first_type>::reference first_reference;
317	typedef typename call_traits<second_type>::reference second_reference;
318	typedef typename call_traits<first_type>::const_reference first_const_reference;
319	typedef typename call_traits<second_type>::const_reference second_const_reference;
320
321	compressed_pair_5() : _first(), _second() {}
322	compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
323	// only one single argument constructor since T1 == T2
324	explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
325	compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c)
326	: _first(c.first()), _second(c.second()) {}
327
328	first_reference first() { return _first; }
329	first_const_reference first() const { return _first; }
330
331	second_reference second() { return _second; }
332	second_const_reference second() const { return _second; }
333
334	void swap(compressed_pair_5& y)
335	{
336	using std::swap;
337	swap(_first, y._first);
338	swap(_second, y._second);
339	}
340	};
341
342	template <bool e1, bool e2, bool same>
343	struct compressed_pair_chooser
344	{
345	template <class T1, class T2>
346	struct rebind
347	{
348	typedef compressed_pair_0<T1, T2> type;
349	};
350	};
351
352	template <>
353	struct compressed_pair_chooser<false, true, false>
354	{
355	template <class T1, class T2>
356	struct rebind
357	{
358	typedef compressed_pair_1<T1, T2> type;
359	};
360	};
361
362	template <>
363	struct compressed_pair_chooser<true, false, false>
364	{
365	template <class T1, class T2>
366	struct rebind
367	{
368	typedef compressed_pair_2<T1, T2> type;
369	};
370	};
371
372	template <>
373	struct compressed_pair_chooser<true, true, false>
374	{
375	template <class T1, class T2>
376	struct rebind
377	{
378	typedef compressed_pair_3<T1, T2> type;
379	};
380	};
381
382	template <>
383	struct compressed_pair_chooser<true, true, true>
384	{
385	template <class T1, class T2>
386	struct rebind
387	{
388	typedef compressed_pair_4<T1, T2> type;
389	};
390	};
391
392	template <>
393	struct compressed_pair_chooser<false, false, true>
394	{
395	template <class T1, class T2>
396	struct rebind
397	{
398	typedef compressed_pair_5<T1, T2> type;
399	};
400	};
401
402	template <class T1, class T2>
403	struct compressed_pair_traits
404	{
405	private:
406	typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
407	typedef typename chooser::template rebind<T1, T2> bound_type;
408	public:
409	typedef typename bound_type::type type;
410	};
411
412	} // namespace detail
413
414	template <class T1, class T2>
415	class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
416	{
417	private:
418	typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
419	public:
420	typedef T1 first_type;
421	typedef T2 second_type;
422	typedef typename call_traits<first_type>::param_type first_param_type;
423	typedef typename call_traits<second_type>::param_type second_param_type;
424	typedef typename call_traits<first_type>::reference first_reference;
425	typedef typename call_traits<second_type>::reference second_reference;
426	typedef typename call_traits<first_type>::const_reference first_const_reference;
427	typedef typename call_traits<second_type>::const_reference second_const_reference;
428
429	compressed_pair() : base_type() {}
430	compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
431	template <class A>
432	explicit compressed_pair(const A& x) : base_type(x){}
433
434	first_reference first() { return base_type::first(); }
435	first_const_reference first() const { return base_type::first(); }
436
437	second_reference second() { return base_type::second(); }
438	second_const_reference second() const { return base_type::second(); }
439	};
440
441	template <class T1, class T2>
442	inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
443	{
444	x.swap(y);
445	}
446
447	#else
448	// no partial specialisation, no member templates:
449
450	template <class T1, class T2>
451	class compressed_pair
452	{
453	private:
454	T1 _first;
455	T2 _second;
456	public:
457	typedef T1 first_type;
458	typedef T2 second_type;
459	typedef typename call_traits<first_type>::param_type first_param_type;
460	typedef typename call_traits<second_type>::param_type second_param_type;
461	typedef typename call_traits<first_type>::reference first_reference;
462	typedef typename call_traits<second_type>::reference second_reference;
463	typedef typename call_traits<first_type>::const_reference first_const_reference;
464	typedef typename call_traits<second_type>::const_reference second_const_reference;
465
466	compressed_pair() : _first(), _second() {}
467	compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
468	explicit compressed_pair(first_param_type x) : _first(x), _second() {}
469	// can't define this in case T1 == T2:
470	// explicit compressed_pair(second_param_type y) : _first(), _second(y) {}
471
472	first_reference first() { return _first; }
473	first_const_reference first() const { return _first; }
474
475	second_reference second() { return _second; }
476	second_const_reference second() const { return _second; }
477
478	void swap(compressed_pair& y)
479	{
480	using std::swap;
481	swap(_first, y._first);
482	swap(_second, y._second);
483	}
484	};
485
486	template <class T1, class T2>
487	inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
488	{
489	x.swap(y);
490	}
491
492	#endif
493
494	} // boost
495
496	#endif // BOOST_OB_COMPRESSED_PAIR_HPP
497
498
499