comparison DEPENDENCIES/generic/include/boost/container/detail/pair.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012.
+// (C) Copyright Ion Gaztanaga 2005-2013.
 //
 // Distributed under 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)
 //

 //////////////////////////////////////////////////////////////////////////////
 
 #ifndef BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
 #define BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
 
-#if defined(_MSC_VER)
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
 
-#include "config_begin.hpp"
+#include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
-
-#include <utility>   //std::pair
-#include <algorithm> //std::swap
-
-#include <boost/move/utility.hpp>
-#include <boost/type_traits/is_class.hpp>
-
-#ifndef BOOST_CONTAINER_PERFECT_FORWARDING
-#include <boost/container/detail/preprocessor.hpp>
-#endif
+#include <boost/move/adl_move_swap.hpp> //swap
+
+#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
+#include <boost/move/utility_core.hpp>
 
 namespace boost {
 namespace container {
 namespace container_detail {
 

    //piecewise_construct missing
    //template <class U, class V> pair(pair<U, V>&& p);
    //template <class... Args1, class... Args2>
    //   pair(piecewise_construct_t, tuple<Args1...> first_args,
    //        tuple<Args2...> second_args);
-/*
-   //Variadic versions
-   template<class U>
-   pair(BOOST_CONTAINER_PP_PARAM(U, u), typename container_detail::disable_if
-         < container_detail::is_pair< typename container_detail::remove_ref_const<U>::type >, pair_nat>::type* = 0)
-      : first(::boost::forward<U>(u))
-      , second()
-   {}
-
-   #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
-   template<class U, class V, class ...Args>
-   pair(U &&u, V &&v)
-      : first(::boost::forward<U>(u))
-      , second(::boost::forward<V>(v), ::boost::forward<Args>(args)...)
-   {}
-
-   #else
-
-   #define BOOST_PP_LOCAL_MACRO(n)                                                            \
-   template<class U, BOOST_PP_ENUM_PARAMS(n, class P)>                                        \
-   pair(BOOST_CONTAINER_PP_PARAM(U, u)                                                          \
-       ,BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                                  \
-      : first(::boost::forward<U>(u))                             \
-      , second(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))                        \
-   {}                                                                                         \
-   //!
-   #define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
-   #include BOOST_PP_LOCAL_ITERATE()
-   #endif
-*/
+
    //pair copy assignment
    pair& operator=(BOOST_COPY_ASSIGN_REF(pair) p)
    {
       first  = p.first;
       second = p.second;

    }
 
    //swap
    void swap(pair& p)
    {
-      using std::swap;
-      swap(this->first, p.first);
-      swap(this->second, p.second);
+      ::boost::adl_move_swap(this->first, p.first);
+      ::boost::adl_move_swap(this->second, p.second);
    }
 };
 
 template <class T1, class T2>
 inline bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y)

 inline pair<T1, T2> make_pair(T1 x, T2 y)
 {  return pair<T1, T2>(x, y); }
 
 template <class T1, class T2>
 inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
-{
-   swap(x.first, y.first);
-   swap(x.second, y.second);
-}
+{  x.swap(y);  }
 
 }  //namespace container_detail {
 }  //namespace container {
 
 

 struct is_enum< ::boost::container::container_detail::pair<T, U> >
 {
    static const bool value = false;
 };
 
+template <class T>
+struct is_class;
+
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 template <class T1, class T2>
 struct is_class< ::boost::container::container_detail::pair<T1, T2> >
-   : public ::boost::true_type
-{};
+{
+   static const bool value = true;
+};
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 
 template<class T1, class T2>
 struct has_move_emulation_enabled< ::boost::container::container_detail::pair<T1, T2> >
-   : ::boost::true_type
-{};
+{
+   static const bool value = true;
+};
 
 #endif
 
+namespace move_detail{
+
+template<class T>
+struct is_class_or_union;
+
+template <class T1, class T2>
+struct is_class_or_union< ::boost::container::container_detail::pair<T1, T2> >
+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+{
+   static const bool value = true;
+};
+
+
+}  //namespace move_detail{
 
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>