| // (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()) {} |
| |
| #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 |
| // Total weirdness. If the assignment to _first is moved after |
| // the call to the inherited operator=, then this breaks graph/test/graph.cpp |
| // by way of iterator_adaptor. |
| compressed_pair_1& operator=(const compressed_pair_1& x) { |
| _first = x._first; |
| T2::operator=(x); |
| return *this; |
| } |
| #endif |
| |
| 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 |
| |
| |
| |