Line data    Source code

       1             : // Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
       2             : //
       3             : // Distributed under the Boost Software License, Version 1.0. (See
       4             : // accompanying file LICENSE_1_0.txt or copy at
       5             : // http://www.boost.org/LICENSE_1_0.txt)
       6             : // For more information, see http://www.boost.org
       7             : 
       8             : 
       9             : #ifndef BOOST_CORE_SWAP_HPP
      10             : #define BOOST_CORE_SWAP_HPP
      11             : 
      12             : // Note: the implementation of this utility contains various workarounds:
      13             : // - swap_impl is put outside the boost namespace, to avoid infinite
      14             : // recursion (causing stack overflow) when swapping objects of a primitive
      15             : // type.
      16             : // - swap_impl has a using-directive, rather than a using-declaration,
      17             : // because some compilers (including MSVC 7.1, Borland 5.9.3, and
      18             : // Intel 8.1) don't do argument-dependent lookup when it has a
      19             : // using-declaration instead.
      20             : // - boost::swap has two template arguments, instead of one, to
      21             : // avoid ambiguity when swapping objects of a Boost type that does
      22             : // not have its own boost::swap overload.
      23             : 
      24             : #include <boost/core/enable_if.hpp>
      25             : #include <boost/config.hpp>
      26             : #include <utility> //for std::swap (C++11)
      27             : #include <algorithm> //for std::swap (C++98)
      28             : #include <cstddef> //for std::size_t
      29             : 
      30             : namespace boost_swap_impl
      31             : {
      32             :   // we can't use type_traits here
      33             : 
      34             :   template<class T> struct is_const { enum _vt { value = 0 }; };
      35             :   template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
      36             : 
      37             :   template<class T>
      38             :   BOOST_GPU_ENABLED
      39           0 :   void swap_impl(T& left, T& right)
      40             :   {
      41             :     using namespace std;//use std::swap if argument dependent lookup fails
      42           0 :     swap(left,right);
      43             :   }
      44             : 
      45             :   template<class T, std::size_t N>
      46             :   BOOST_GPU_ENABLED
      47             :   void swap_impl(T (& left)[N], T (& right)[N])
      48             :   {
      49             :     for (std::size_t i = 0; i < N; ++i)
      50             :     {
      51             :       ::boost_swap_impl::swap_impl(left[i], right[i]);
      52             :     }
      53             :   }
      54             : }
      55             : 
      56             : namespace boost
      57             : {
      58             :   template<class T1, class T2>
      59             :   BOOST_GPU_ENABLED
      60             :   typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
      61           0 :   swap(T1& left, T2& right)
      62             :   {
      63           0 :     ::boost_swap_impl::swap_impl(left, right);
      64             :   }
      65             : }
      66             : 
      67             : #endif