Update CMakeLists.txt

Mark boost::swap noexcept if the type supports non-throwing swap
implementation.

CMakeLists.txt

@@ -20,6 +20,15 @@ target_link_libraries(boost_core
     Boost::throw_exception
 )
 
+if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+
+  file(GLOB_RECURSE boost_core_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
+  source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_core_IDEFILES} PREFIX "Header Files")
+  list(APPEND boost_core_IDEFILES extra/boost_core.natvis)
+  target_sources(boost_core PRIVATE ${boost_core_IDEFILES})
+
+endif()
+
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
   add_subdirectory(test)

appveyor.yml

@@ -59,6 +59,13 @@ environment:
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_SUBDIR: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      CMAKE_INSTALL: 1
+
 install:
   - set GIT_FETCH_JOBS=8
   - set BOOST_BRANCH=develop
@@ -70,7 +77,7 @@ install:
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
   - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" core
   - cmd /c bootstrap
-  - b2 headers
+  - b2 -d0 headers
 
 build: off
 
@@ -78,4 +85,27 @@ test_script:
   - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
   - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+  - if "%CMAKE%%CMAKE_SUBDIR%%CMAKE_INSTALL%" == ""  b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+
+  - if not "%CMAKE%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE%" == ""  cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=core ..
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Debug & ctest --output-on-failure --no-tests=error -j 3 -C Debug
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Release & ctest --output-on-failure --no-tests=error -j 3 -C Release
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config MinSizeRel & ctest --output-on-failure --no-tests=error -j 3 -C MinSizeRel
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config RelWithDebInfo & ctest --output-on-failure --no-tests=error -j 3 -C RelWithDebInfo
+
+  - if not "%CMAKE_SUBDIR%" == ""  cd libs/core/test/cmake_subdir_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_SUBDIR%" == ""  cmake ..
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config MinSizeRel && cmake --build . --target check --config MinSizeRel
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config RelWithDebInfo && cmake --build . --target check --config RelWithDebInfo
+
+  - if not "%CMAKE_INSTALL%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DBOOST_INCLUDE_LIBRARIES=core -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Release
+  - if not "%CMAKE_INSTALL%" == ""  cd ../libs/core/test/cmake_install_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release

doc/changes.qbk

@@ -14,6 +14,8 @@
 * Deprecated `boost/core/is_same.hpp` and `boost::core::is_same`. The header will be removed in a future release.
   Users are advised to use [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
   or C++ standard library type traits instead.
+* Marked `boost::ref` member functions and associated methods with `noexcept`.
+* Marked `boost::swap` function with `noexcept`, depending on whether the type supports a non-throwing swap operation.
 
 [endsect]
 

doc/swap.qbk

@@ -22,7 +22,7 @@
 
 [section Header <boost/core/swap.hpp>]
 
-`template<class T> void swap(T& left, T& right);`
+[^template<class T> void swap(T& left, T& right) noexcept(['see below]);]
 
 [endsect]
 
@@ -40,13 +40,14 @@ specialized swap function is available, `std::swap` is used.
 The generic `std::swap` function requires that the elements
 to be swapped are assignable and copy constructible. It is
 usually implemented using one copy construction and two
-assignments - this is often both unnecessarily restrictive and
-unnecessarily slow. In addition, where the generic swap
-implementation provides only the basic guarantee, specialized
-swap functions are often able to provide the no-throw exception
-guarantee (and it is considered best practice to do so where
-possible [footnote Scott Meyers, Effective C++ Third Edition,
-Item 25: "Consider support for a non-throwing swap"].
+assignments (C++11 replaces copy operations with move) - this
+is often both unnecessarily restrictive and unnecessarily slow.
+In addition, where the generic swap implementation provides
+only the basic guarantee, specialized swap functions are often
+able to provide the no-throw exception guarantee (and it is
+considered best practice to do so where possible[footnote Scott
+Meyers, Effective C++ Third Edition, Item 25: "Consider support
+for a non-throwing swap"].
 
 The alternative to using argument dependent lookup in this
 situation is to provide a template specialization of
@@ -59,12 +60,12 @@ in their own namespaces.
 `std::swap` originally did not do so, but a request to add an
 overload of `std::swap` for built-in arrays has been accepted
 by the C++ Standards Committee[footnote
-  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809 
+  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809
   LWG Defect Report 809: std::swap should be overloaded for array
   types]].
 
 [endsect]
-    
+
 [section Exception Safety]
 
 `boost::swap` provides the same exception guarantee as the
@@ -73,30 +74,33 @@ of type `T[n]`, where `n > 1` and the underlying swap function
 for `T` provides the strong exception guarantee, `boost::swap`
 provides only the basic exception guarantee.
 
+In C++11 and later, `boost::swap` propagates the same `noexcept`
+specification as the one specified in the underlying swap function.
+
 [endsect]
 
 [section Requirements]
 
 Either:
 
-* T must be assignable
-* T must be copy constructible
+* `T` must be copy assignable (/since C++11:/ move assignable)
+* `T` must be copy constructible (/since C++11:/ move constructible)
 
 Or:
 
-* A function with the signature `swap(T&,T&)` is available via
+* A function with the signature `swap(T&, T&)` is available via
   argument dependent lookup
 
 Or:
 
-* A template specialization of `std::swap` exists for T
+* A template specialization of `std::swap` exists for `T`
 
 Or:
 
-* T is a built-in array of swappable elements
+* `T` is a built-in array of swappable elements
 
 [endsect]
-    
+
 [section Portability]
 
 Several older compilers do not support argument dependent
@@ -104,11 +108,11 @@ lookup. On these compilers `boost::swap` will call
 `std::swap`, ignoring any specialized swap functions that
 could be found as a result of argument dependent lookup.
 
-[endsect]    
+[endsect]
 
 [section Credits]
 
-* *Niels Dekker* - for implementing and documenting support for 
+* *Niels Dekker* - for implementing and documenting support for
   built-in arrays
 * *Joseph Gauterin* - for the initial idea, implementation,
   tests, and documentation

extra/boost_core.natvis

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+  <Type Name="boost::core::basic_string_view&lt;*&gt;">
+    <DisplayString>{p_,[n_]s}</DisplayString>
+  </Type>
+
+</AutoVisualizer>

include/boost/core/ref.hpp

@@ -1,17 +1,15 @@
 #ifndef BOOST_CORE_REF_HPP
 #define BOOST_CORE_REF_HPP
 
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/addressof.hpp>
 #include <boost/core/enable_if.hpp>
 
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
@@ -61,9 +59,11 @@ template< class Y, class T > struct ref_convertible
     enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 
+#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
 struct ref_empty
 {
 };
+#endif
 
 } // namespace detail
 
@@ -92,11 +92,11 @@ public:
 
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+    BOOST_FORCEINLINE explicit reference_wrapper(T& t) BOOST_NOEXCEPT : t_(boost::addressof(t)) {}
 
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
 
-    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ) BOOST_NOEXCEPT : t_( boost::addressof( t ) ) {}
 
 #endif
 
@@ -117,30 +117,37 @@ public:
      @remark Only enabled when `Y*` is convertible to `T*`.
      @remark Does not throw.
     */
-    template<class Y> reference_wrapper( reference_wrapper<Y> r,
-        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
-            boost::detail::ref_empty>::type = boost::detail::ref_empty() ): t_( r.t_ )
+#if !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class = typename enable_if_c<boost::detail::ref_convertible<Y, T>::value>::type>
+    reference_wrapper( reference_wrapper<Y> r ) BOOST_NOEXCEPT : t_( r.t_ )
     {
     }
+#else
+    template<class Y> reference_wrapper( reference_wrapper<Y> r,
+        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
+            boost::detail::ref_empty>::type = boost::detail::ref_empty() ) BOOST_NOEXCEPT : t_( r.t_ )
+    {
+    }
+#endif
 
     /**
      @return The stored reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE operator T& () const { return *t_; }
+    BOOST_FORCEINLINE operator T& () const BOOST_NOEXCEPT { return *t_; }
 
     /**
      @return The stored reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE T& get() const { return *t_; }
+    BOOST_FORCEINLINE T& get() const BOOST_NOEXCEPT { return *t_; }
 
     /**
      @return A pointer to the object referenced by the stored
        reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+    BOOST_FORCEINLINE T* get_pointer() const BOOST_NOEXCEPT { return t_; }
 
 private:
 
@@ -165,7 +172,7 @@ private:
  @return `reference_wrapper<T>(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t ) BOOST_NOEXCEPT
 {
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
 
@@ -184,7 +191,7 @@ template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T
  @return `reference_wrapper<T const>(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t ) BOOST_NOEXCEPT
 {
     return reference_wrapper<T const>(t);
 }
@@ -315,7 +322,7 @@ template<typename T> struct unwrap_reference< reference_wrapper<T> const volatil
  @return `unwrap_reference<T>::type&(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t ) BOOST_NOEXCEPT
 {
     return t;
 }
@@ -325,7 +332,7 @@ template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_r
 /**
  @cond
 */
-template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r ) BOOST_NOEXCEPT
 {
     return r.get_pointer();
 }

include/boost/core/swap.hpp

@@ -13,10 +13,10 @@
 // - swap_impl is put outside the boost namespace, to avoid infinite
 // recursion (causing stack overflow) when swapping objects of a primitive
 // type.
-// - swap_impl has a using-directive, rather than a using-declaration,
-// because some compilers (including MSVC 7.1, Borland 5.9.3, and
-// Intel 8.1) don't do argument-dependent lookup when it has a
-// using-declaration instead.
+// - std::swap is imported with a using-directive, rather than
+// a using-declaration, because some compilers (including MSVC 7.1,
+// Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
+// when it has a using-declaration instead.
 // - boost::swap has two template arguments, instead of one, to
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
@@ -30,6 +30,17 @@
 #endif
 #include <cstddef> // for std::size_t
 
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(BOOST_GCC) && (BOOST_GCC < 40700)
+// gcc 4.6 ICEs on noexcept specifications below
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x)
+#else
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x) BOOST_NOEXCEPT_IF(x)
+#endif
+
 namespace boost_swap_impl
 {
   // we can't use type_traits here
@@ -37,17 +48,22 @@ namespace boost_swap_impl
   template<class T> struct is_const { enum _vt { value = 0 }; };
   template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
 
+  // Use std::swap if argument dependent lookup fails.
+  // We need to have this at namespace scope to be able to use unqualified swap() call
+  // in noexcept specification.
+  using namespace std;
+
   template<class T>
   BOOST_GPU_ENABLED
-  void swap_impl(T& left, T& right)
+  void swap_impl(T& left, T& right) BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(swap(left, right)))
   {
-    using namespace std;//use std::swap if argument dependent lookup fails
-    swap(left,right);
+    swap(left, right);
   }
 
   template<class T, std::size_t N>
   BOOST_GPU_ENABLED
   void swap_impl(T (& left)[N], T (& right)[N])
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left[0], right[0])))
   {
     for (std::size_t i = 0; i < N; ++i)
     {
@@ -62,9 +78,12 @@ namespace boost
   BOOST_GPU_ENABLED
   typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
   swap(T1& left, T2& right)
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left, right)))
   {
     ::boost_swap_impl::swap_impl(left, right);
   }
 }
 
-#endif
+#undef BOOST_CORE_SWAP_NOEXCEPT_IF
+
+#endif // BOOST_CORE_SWAP_HPP

test/swap/Jamfile.v2

@@ -13,6 +13,7 @@ compile swap_lib_header_1.cpp ;
 compile swap_lib_header_2.cpp ;
 compile swap_mixed_headers_1.cpp ;
 compile swap_mixed_headers_2.cpp ;
+compile swap_noexcept.cpp ;
 
 compile-fail swap_const_wrapper_fail.cpp ;
 

test/swap/swap_array_of_class.cpp

@@ -46,13 +46,13 @@ int main()
   const std::size_t array_size = 2;
   const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
   const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
-  
+
   swap_test_class array1[array_size];
   swap_test_class array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   swap_test_class::reset();
   boost::swap(array1, array2);
 

test/swap/swap_array_of_int.cpp

@@ -20,13 +20,13 @@ int main()
   const std::size_t array_size = 3;
   const int initial_array1[array_size] = { 1, 2, 3 };
   const int initial_array2[array_size] = { 4, 5, 6 };
-  
+
   int array1[array_size];
   int array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   boost::swap(array1, array2);
 
   BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));

test/swap/swap_array_of_template.cpp

@@ -52,13 +52,13 @@ int main()
   const std::size_t array_size = 2;
   const swap_test_template<int> initial_array1[array_size] = { { swap_test_class(1) }, { swap_test_class(2) } };
   const swap_test_template<int> initial_array2[array_size] = { { swap_test_class(3) }, { swap_test_class(4) } };
-  
+
   swap_test_template<int> array1[array_size];
   swap_test_template<int> array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   swap_test_class::reset();
   boost::swap(array1, array2);
 

test/swap/swap_const_wrapper_fail.cpp

@@ -6,7 +6,7 @@
 
 namespace boost
 {
-  
+
 template<class T> struct Wrapper
 {
     T value;
@@ -16,9 +16,9 @@ template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
 {
     boost::swap( w, v );
 }
-  
+
 } // namespace boost
- 
+
 int main()
 {
     boost::Wrapper<int> const w = { 2 };

test/swap/swap_noexcept.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2023 Andrey Semashev
+//
+// 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)
+
+// Tests that boost::swap propagates noexcept specification correctly
+
+#include <boost/core/swap.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) && \
+    !(defined(BOOST_GCC) && (BOOST_GCC < 40700))
+
+namespace test_ns {
+
+struct class_with_noexcept_swap
+{
+    static class_with_noexcept_swap& instance() noexcept;
+
+    friend void swap(class_with_noexcept_swap&, class_with_noexcept_swap&) noexcept
+    {
+    }
+};
+
+struct class_with_except_swap
+{
+    static class_with_except_swap& instance() noexcept;
+
+    friend void swap(class_with_except_swap&, class_with_except_swap&)
+    {
+    }
+};
+
+} // namespace test_ns
+
+static_assert(noexcept(boost::swap(test_ns::class_with_noexcept_swap::instance(), test_ns::class_with_noexcept_swap::instance())),
+    "boost::swap for class_with_noexcept_swap should have noexcept specification");
+static_assert(!noexcept(boost::swap(test_ns::class_with_except_swap::instance(), test_ns::class_with_except_swap::instance())),
+    "boost::swap for class_with_except_swap should not have noexcept specification");
+
+#endif // !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) ...

test/swap/swap_specialized_in_boost.cpp

@@ -31,7 +31,7 @@ int main()
 
   boost::swap_test_class object1 = initial_value1;
   boost::swap_test_class object2 = initial_value2;
-  
+
   boost::swap_test_class::reset();
   boost::swap(object1,object2);
 

test/swap/swap_specialized_in_boost_and_other.cpp

@@ -10,7 +10,7 @@
 // in an other namespace to have a custom swap function in boost, because the
 // boost::swap utility should find the swap function in the other namespace, by
 // argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
-// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and 
+// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and
 // Borland 5.9.3. Users of those compilers might consider adding a swap overload
 // to the boost namespace.
 
@@ -50,13 +50,13 @@ int main()
 
   other::swap_test_class object1 = initial_value1;
   other::swap_test_class object2 = initial_value2;
-  
+
   other::swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_global.cpp

@@ -25,13 +25,13 @@ int main()
 
   swap_test_class object1 = initial_value1;
   swap_test_class object2 = initial_value2;
-  
+
   swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_other.cpp

@@ -31,13 +31,13 @@ int main()
 
   other::swap_test_class object1 = initial_value1;
   other::swap_test_class object2 = initial_value2;
-  
+
   other::swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_std.cpp

@@ -30,13 +30,13 @@ int main()
 
   swap_test_class object1 = initial_value1;
   swap_test_class object2 = initial_value2;
-  
+
   swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 

test/swap/swap_std_typeinfo_ptr.cpp

@@ -19,7 +19,7 @@ int main()
 {
   const std::type_info * const initial_value1 = 0;
   const std::type_info * const initial_value2 = &typeid(double);
-  
+
   const std::type_info * ptr1 = initial_value1;
   const std::type_info * ptr2 = initial_value2;
 

test/swap/swap_std_vector_of_boost.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having boost::swap_test_class as vector element type. 
+// having boost::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class_type(1));
   const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);
@@ -52,7 +52,7 @@ int main()
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
   BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
 

test/swap/swap_std_vector_of_global.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having ::swap_test_class as vector element type. 
+// having ::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -17,7 +17,7 @@
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 
-//Provide swap function in the global namespace 
+//Provide swap function in the global namespace
 void swap(swap_test_class& left, swap_test_class& right)
 {
   left.swap(right);
@@ -32,12 +32,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class(1));
   const vector_type initial_value2(initial_size2, swap_test_class(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);

test/swap/swap_std_vector_of_other.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having other::swap_test_class as vector element type. 
+// having other::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class_type(1));
   const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);

test/swap/swap_test_class.hpp

@@ -59,7 +59,7 @@ public:
   {
     m_data = arg;
   }
-  
+
   static unsigned int swap_count(){ return swapCount(); }
   static unsigned int copy_count(){ return copyCount(); }
   static unsigned int construct_count(){ return constructCount(); }
@@ -68,7 +68,7 @@ public:
   static void reset()
   {
     swapCount() = 0;
-    copyCount() = 0;    
+    copyCount() = 0;
     constructCount() = 0;
     destructCount() = 0;
   }
@@ -80,19 +80,19 @@ private:
     return value;
   }
 
-  static unsigned int& copyCount()    
+  static unsigned int& copyCount()
   {
     static unsigned int value = 0;
     return value;
   }
 
-  static unsigned int& constructCount()    
+  static unsigned int& constructCount()
   {
     static unsigned int value = 0;
     return value;
   }
 
-  static unsigned int& destructCount()    
+  static unsigned int& destructCount()
   {
     static unsigned int value = 0;
     return value;