Remove inclusion of <algorithm>

doc/array/reference.adoc

@@ -19,7 +19,7 @@ namespace boost {
   template<typename T, std::size_t N> class array;
 
   template<typename T, std::size_t N>
-    constexpr void swap(array<T, N>&, array<T, N>&);
+    void swap(array<T, N>&, array<T, N>&);
 
   template<typename T, std::size_t N>
     constexpr bool operator==(const array<T, N>&, const array<T, N>&);
@@ -120,7 +120,7 @@ public:
 
   // modifiers
 
-  constexpr void swap(array<T, N>&);
+  swap(array<T, N>&);
 
   constexpr void fill(const T&);
   void assign(const T&); // deprecated
@@ -290,10 +290,10 @@ Remarks: :: This function is deprecated. Use `data()` instead.
 ### Modifiers
 
 ```
-constexpr void swap(array<T, N>& other);
+void swap(array<T, N>& other);
 ```
 [horizontal]
-Effects: :: for each `i` in `[0..N)`, calls `swap(elems[i], other.elems[i])`.
+Effects: :: `std::swap(elems, other.elems)`.
 Complexity: :: linear in `N`.
 
 ---
@@ -319,7 +319,7 @@ Remarks: :: An obsolete and deprecated spelling of `fill`. Use `fill` instead.
 
 ```
 template<typename T, std::size_t N>
-  constexpr void swap(array<T, N>& x, array<T, N>& y);
+  void swap(array<T, N>& x, array<T, N>& y);
 ```
 [horizontal]
 Effects: :: `x.swap(y)`.

include/boost/array.hpp

@@ -37,18 +37,17 @@
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 # pragma warning(push)
-# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
 # pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
-# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
+# pragma warning(disable:4512) // boost::array<T,N>' : assignment operator could not be generated
+# pragma warning(disable:4610) // class 'boost::array<T,N>' can never be instantiated - user defined constructor required
 #endif
 
 #include <boost/assert.hpp>
-#include <boost/core/invoke_swap.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
-#include <algorithm>
 #include <iterator>
 #include <stdexcept>
+#include <utility>
 #include <cstddef>
 
 namespace boost {
@@ -143,9 +142,9 @@ namespace boost {
         enum { static_size = N };
 
         // swap (note: linear complexity)
-        BOOST_CXX14_CONSTEXPR void swap (array<T,N>& y) {
-            for (size_type i = 0; i < N; ++i)
-                boost::core::invoke_swap(elems[i],y.elems[i]);
+        BOOST_CXX14_CONSTEXPR void swap (array<T,N>& y)
+        {
+            std::swap( elems, y.elems );
         }
 
         // direct access to data
@@ -158,15 +157,29 @@ namespace boost {
 
         // assignment with type conversion
         template <typename T2>
-        array<T,N>& operator= (const array<T2,N>& rhs) {
-            std::copy(rhs.begin(),rhs.end(), begin());
+        array<T,N>& operator= (const array<T2,N>& rhs)
+        {
+            for( std::size_t i = 0; i < N; ++i )
+            {
+                elems[ i ] = rhs.elems[ i ];
+            }
+
             return *this;
         }
 
         // fill with one value
         BOOST_CXX14_CONSTEXPR void fill (const T& value)
         {
-            std::fill_n(begin(),size(),value);
+            // using elems[ 0 ] as a temporary copy
+            // avoids the aliasing opportunity betw.
+            // `value` and `elems`
+
+            elems[ 0 ] = value;
+
+            for( std::size_t i = 1; i < N; ++i )
+            {
+                elems[ i ] = elems[ 0 ];
+            }
         }
 
         // an obsolete synonym for fill
@@ -264,7 +277,8 @@ namespace boost {
         static BOOST_CONSTEXPR size_type max_size() BOOST_NOEXCEPT { return 0; }
         enum { static_size = 0 };
 
-        void swap (array<T,0>& /*y*/) {
+        BOOST_CXX14_CONSTEXPR void swap (array<T,0>& /*y*/)
+        {
         }
 
         // direct access to data
@@ -370,7 +384,7 @@ namespace boost {
 
     // global swap()
     template<class T, std::size_t N>
-    inline void swap (array<T,N>& x, array<T,N>& y) {
+    BOOST_CXX14_CONSTEXPR inline void swap (array<T,N>& x, array<T,N>& y) {
         x.swap(y);
     }
 

test/array0.cpp

@@ -5,11 +5,11 @@
  * http://www.boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/array.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <algorithm>
 #include <string>
 #include <iostream>
-#include <boost/array.hpp>
-
-#include <boost/core/lightweight_test_trait.hpp>
 
 namespace {