From aa8dcb47cf46a1656edde03761c178cbc65010f7 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Sat, 15 Jul 2017 18:57:34 +0300
Subject: [PATCH] Add is_nothrow_swappable

---
 doc/is_nothrow_swappable.qbk                  |  23 +++
 doc/type_traits.qbk                           |   2 +
 include/boost/type_traits.hpp                 |   1 +
 .../type_traits/is_nothrow_swappable.hpp      |  47 ++++++
 test/is_nothrow_swappable_test.cpp            | 135 ++++++++++++++++++
 5 files changed, 208 insertions(+)
 create mode 100644 doc/is_nothrow_swappable.qbk
 create mode 100644 include/boost/type_traits/is_nothrow_swappable.hpp
 create mode 100644 test/is_nothrow_swappable_test.cpp

diff --git a/doc/is_nothrow_swappable.qbk b/doc/is_nothrow_swappable.qbk
new file mode 100644
index 0000000..8e5886e
--- /dev/null
+++ b/doc/is_nothrow_swappable.qbk
@@ -0,0 +1,23 @@
+[/ 
+  Copyright 2017 Peter Dimov
+
+  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).
+]
+
+[section:is_nothrow_swappable is_nothrow_swappable]
+
+   template <class T>
+   struct is_nothrow_swappable : public __tof {};
+
+__inherit If the expression `swap(declval<T&>(), declval<T&>())` (in a context
+where `std::swap` is visible) is valid and non-throwing, inherits from
+__true_type, otherwise from __false_type.
+
+__compat This trait requires C++11.
+
+__header ` #include <boost/type_traits/is_nothrow_swappable.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
diff --git a/doc/type_traits.qbk b/doc/type_traits.qbk
index 1a1fa5b..5dea9ad 100644
--- a/doc/type_traits.qbk
+++ b/doc/type_traits.qbk
@@ -100,6 +100,7 @@
 [def __is_nothrow_move_constructible [link boost_typetraits.reference.is_nothrow_move_constructible is_nothrow_move_constructible]]
 [def __has_nothrow_assign [link boost_typetraits.reference.has_nothrow_assign has_nothrow_assign]]
 [def __is_nothrow_move_assignable [link boost_typetraits.reference.is_nothrow_move_assignable is_nothrow_move_assignable]]
+[def __is_nothrow_swappable [link boost_typetraits.reference.is_nothrow_swappable is_nothrow_swappable]]
 
 [def __is_base_of [link boost_typetraits.reference.is_base_of is_base_of]]
 [def __is_virtual_base_of [link boost_typetraits.reference.is_virtual_base_of is_virtual_base_of]]
@@ -300,6 +301,7 @@ See __has_trivial_constructor.
 [include is_member_pointer.qbk]
 [include is_nothrow_move_assignable.qbk]
 [include is_nothrow_move_constructible.qbk]
+[include is_nothrow_swappable.qbk]
 [include is_object.qbk]
 [include is_pod.qbk]
 [include is_pointer.qbk]
diff --git a/include/boost/type_traits.hpp b/include/boost/type_traits.hpp
index dbc8c95..0e6a7aa 100644
--- a/include/boost/type_traits.hpp
+++ b/include/boost/type_traits.hpp
@@ -113,6 +113,7 @@
 #include <boost/type_traits/is_member_pointer.hpp>
 #include <boost/type_traits/is_nothrow_move_assignable.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_nothrow_swappable.hpp>
 #include <boost/type_traits/is_object.hpp>
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/is_pointer.hpp>
diff --git a/include/boost/type_traits/is_nothrow_swappable.hpp b/include/boost/type_traits/is_nothrow_swappable.hpp
new file mode 100644
index 0000000..b355664
--- /dev/null
+++ b/include/boost/type_traits/is_nothrow_swappable.hpp
@@ -0,0 +1,47 @@
+#ifndef BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED
+#define BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED
+
+//  Copyright 2017 Peter Dimov
+//
+//  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
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+#else
+
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <algorithm>
+
+namespace boost
+{
+
+namespace type_traits_swappable_detail
+{
+
+using std::swap;
+
+template<class T, class U, bool B = noexcept(swap(declval<T>(), declval<U>()))> integral_constant<bool, B> is_nothrow_swappable_with_impl( int );
+template<class T, class U> false_type is_nothrow_swappable_with_impl( ... );
+
+template<class T, bool B = noexcept(swap(declval<T&>(), declval<T&>()))> integral_constant<bool, B> is_nothrow_swappable_impl( int );
+template<class T> false_type is_nothrow_swappable_impl( ... );
+
+} // namespace type_traits_swappable_detail
+
+template<class T, class U> struct is_nothrow_swappable_with: decltype( type_traits_swappable_detail::is_nothrow_swappable_with_impl<T, U>(0) )
+{
+};
+
+template<class T> struct is_nothrow_swappable: decltype( type_traits_swappable_detail::is_nothrow_swappable_impl<T>(0) )
+{
+};
+
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED
diff --git a/test/is_nothrow_swappable_test.cpp b/test/is_nothrow_swappable_test.cpp
new file mode 100644
index 0000000..52915b6
--- /dev/null
+++ b/test/is_nothrow_swappable_test.cpp
@@ -0,0 +1,135 @@
+
+//  Copyright 2017 Peter Dimov
+//
+//  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
+
+#ifdef TEST_STD
+#  include <type_traits>
+#else
+#  include <boost/type_traits/is_nothrow_swappable.hpp>
+#endif
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+
+int main()
+{
+}
+
+#else
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+#include <vector>
+#include <utility>
+
+struct X
+{
+};
+
+struct Y
+{
+    Y( Y const& ) {}
+};
+
+struct Z
+{
+    Z& operator=( Z const& ) { return *this; }
+};
+
+struct V
+{
+    V( V const& ) {}
+    V& operator=( V const& ) { return *this; }
+};
+
+void swap( V&, V& ) noexcept {}
+
+TT_TEST_BEGIN(is_nothrow_swappable)
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int volatile>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int[2]>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int const[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int volatile[2]>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<int const volatile[2]>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<void>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<void const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<void volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<void const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X[2]>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X const[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X volatile[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<X const volatile[2]>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y const[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y volatile[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Y const volatile[2]>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z const[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z volatile[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<Z const volatile[2]>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V[2]>::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V const[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V volatile[2]>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<V const volatile[2]>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<int> >::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<int> const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<int> volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<int> const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<Y> >::value, true);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<Y> const>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<Y> volatile>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_nothrow_swappable<std::vector<Y> const volatile>::value, false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<X, int> >::value), true);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<X, int> const>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<X, int> volatile>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<X, int> const volatile>::value), false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<Y, int> >::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<Y, int> const>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<Y, int> volatile>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<Y, int> const volatile>::value), false);
+
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<V, int> >::value), true);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<V, int> const>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<V, int> volatile>::value), false);
+BOOST_CHECK_INTEGRAL_CONSTANT((::tt::is_nothrow_swappable<std::pair<V, int> const volatile>::value), false);
+
+TT_TEST_END
+
+#endif