Save state before 1.36 merges.

[SVN r47337]

call_traits.htm

@@ -740,26 +740,16 @@ specialisation).</p>
 
 <p>Revised 01 September 2000</p>
 
-<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
-sell and distribute this document is granted provided this
-copyright notice appears in all copies. This document is provided
-&quot;as is&quot; without express or implied warranty, and with
-no claim as to its suitability for any purpose.</p>
-
-<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
-Hinnant and John Maddock.</p>
-
-<p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John
-Maddock</a>, the latest version of this file can be found at <a
-href="http://www.boost.org/">www.boost.org</a>, and the boost
-discussion list at <a
-href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
-
-<p>.</p>
-
-<p>&nbsp;</p>
-
-<p>&nbsp;</p>
+   <p>
+      Copyright 2000 Steve Cleary, Beman Dawes, Howard
+      Hinnant and John Maddock. <br/>
+      Use, modification and distribution are subject to the
+      Boost Software License, Version 1.0.
+      (See accompanying file LICENSE_1_0.txt
+      or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+         http://www.boost.org/LICENSE_1_0.txt
+      </a>).
+   </p>
 </body>
 </html>
 

enable_if.html

@@ -366,17 +366,18 @@ David Vandevoorde and Nicolai M. Josuttis.
 <EM>C++ Templates: The Complete Guide</EM>.
 Addison-Wesley, 2002.</DL>
 
-
-
-
-
-<hr></hr>
-
-<B>Contributed by:</B> <BR>
-Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
+<hr/>
+   <p>Copyright Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
 <EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
 Indiana University<BR>
-Open Systems Lab
+Open Systems Lab<br/>
+Use, modification and distribution are subject to the
+Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt
+or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+   http://www.boost.org/LICENSE_1_0.txt
+</a>).
+</p>
 <!--HTMLFOOT-->
 <!--ENDHTML-->
 <!--FOOTER-->

enable_if/test/constructors.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/dummy_arg_disambiguation.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/lazy.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/lazy_test.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/member_templates.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/namespace_disambiguation.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/no_disambiguation.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

enable_if/test/partial_specializations.cpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

include/boost/exception.hpp

@@ -0,0 +1,19 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_1D94A7C6054E11DB9804B622A1EF5492
+#define UUID_1D94A7C6054E11DB9804B622A1EF5492
+
+#include <boost/exception/diagnostic_information.hpp>
+#include <boost/exception/enable_current_exception.hpp>
+#include <boost/exception/enable_error_info.hpp>
+#include <boost/exception/error_info.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/exception/info.hpp>
+#include <boost/exception/info_tuple.hpp>
+#include <boost/exception_ptr.hpp>
+#include <boost/throw_exception.hpp>
+
+#endif

include/boost/operators.hpp

@@ -8,6 +8,8 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.
 
 //  Revision History
+//  03 Apr 08 Make sure "convertible to bool" is sufficient
+//            for T::operator<, etc. (Daniel Frey)
 //  24 May 07 Changed empty_base to depend on T, see
 //            http://svn.boost.org/trac/boost/ticket/979
 //  21 Oct 02 Modified implementation of operators to allow compilers with a
@@ -124,34 +126,34 @@ namespace boost
 template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct less_than_comparable2 : B
 {
-     friend bool operator<=(const T& x, const U& y) { return !(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !(x < y); }
+     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
      friend bool operator>(const U& x, const T& y)  { return y < x; }
      friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
+     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
 };
 
 template <class T, class B = ::boost::detail::empty_base<T> >
 struct less_than_comparable1 : B
 {
      friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
+     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
 };
 
 template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct equality_comparable2 : B
 {
      friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
+     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
 };
 
 template <class T, class B = ::boost::detail::empty_base<T> >
 struct equality_comparable1 : B
 {
-     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
+     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
 };
 
 // A macro which produces "name_2left" from "name".
@@ -356,7 +358,7 @@ struct equivalent2 : B
 {
   friend bool operator==(const T& x, const U& y)
   {
-    return !(x < y) && !(x > y);
+    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
   }
 };
 
@@ -365,7 +367,7 @@ struct equivalent1 : B
 {
   friend bool operator==(const T&x, const T&y)
   {
-    return !(x < y) && !(y < x);
+    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
   }
 };
 
@@ -373,17 +375,17 @@ template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct partially_ordered2 : B
 {
   friend bool operator<=(const T& x, const U& y)
-    { return (x < y) || (x == y); }
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
   friend bool operator>=(const T& x, const U& y)
-    { return (x > y) || (x == y); }
+    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
   friend bool operator>(const U& x, const T& y)
     { return y < x; }
   friend bool operator<(const U& x, const T& y)
     { return y > x; }
   friend bool operator<=(const U& x, const T& y)
-    { return (y > x) || (y == x); }
+    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
   friend bool operator>=(const U& x, const T& y)
-    { return (y < x) || (y == x); }
+    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
 };
 
 template <class T, class B = ::boost::detail::empty_base<T> >
@@ -392,9 +394,9 @@ struct partially_ordered1 : B
   friend bool operator>(const T& x, const T& y)
     { return y < x; }
   friend bool operator<=(const T& x, const T& y)
-    { return (x < y) || (x == y); }
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
   friend bool operator>=(const T& x, const T& y)
-    { return (y < x) || (x == y); }
+    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
 };
 
 //  Combined operator classes (contributed by Daryle Walker) ----------------//

include/boost/ref.hpp

@@ -15,7 +15,7 @@
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
-//  Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
@@ -173,6 +173,12 @@ class unwrap_reference
 
 # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
+template <class T> inline typename unwrap_reference<T>::type&
+unwrap_ref(T& t)
+{
+    return t;
+}
+
 } // namespace boost
 
 #endif // #ifndef BOOST_REF_HPP_INCLUDED

include/boost/swap.hpp

@@ -0,0 +1,12 @@
+// Copyright (C) 2007 Joseph Gauterin
+//
+// 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_SWAP_HPP
+#define BOOST_SWAP_HPP
+
+#include "./utility/swap.hpp"
+
+#endif

include/boost/utility/addressof.hpp

@@ -1,6 +1,7 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
-//                    Peter Dimov
+//
+// Copyright (C) 2002, 2008 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -14,27 +15,31 @@
 # include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>
 
-namespace boost {
-
-// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov)
-
-// VC7 strips const from nested classes unless we add indirection here
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-
-template<class T> struct _addp
+namespace boost
 {
-    typedef T * type;
+
+namespace detail
+{
+
+template<class T> struct addressof_impl
+{
+    static inline T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+
+    static inline T * f( T * v, int )
+    {
+        return v;
+    }
 };
-    
-template <typename T> typename _addp<T>::type
 
-# else
-template <typename T> T*
-# endif
-addressof(T& v)
+} // namespace detail
+
+template<class T> T * addressof( T & v )
 {
-  return reinterpret_cast<T*>(
-       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    return boost::detail::addressof_impl<T>::f( v, 0 );
 }
 
 // Borland doesn't like casting an array reference to a char reference
@@ -53,6 +58,6 @@ const T (*addressof(const T (&t)[N]))[N]
 }
 # endif
 
-}
+} // namespace boost
 
 #endif // BOOST_UTILITY_ADDRESSOF_HPP

include/boost/utility/detail/result_of_iterate.hpp

@@ -10,6 +10,46 @@
 # error Boost result_of - do not include this file!
 #endif
 
+#if defined(BOOST_HAS_DECLTYPE)
+
+// As of N2588, C++0x result_of only supports function call
+// expressions of the form f(x). This precludes support for member
+// function pointers, which are invoked with expressions of the form
+// o->*f(x). This implementation supports both.
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , detail::result_of_impl<
+              F, F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
+          >
+        , detail::result_of_decltype_impl<
+              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
+          >
+      >::type
+{};
+
+namespace detail {
+
+# define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
+     static T ## n t ## n; \
+  /**/
+
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+class result_of_decltype_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+{
+  static F f;
+  BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
+public:
+  typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
+};
+
+} // namespace detail 
+
+#else // defined(BOOST_HAS_DECLTYPE)
+
 // CWPro8 requires an argument in a function type specialization
 #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
 # define BOOST_RESULT_OF_ARGS void
@@ -26,6 +66,8 @@ struct result_of<F(BOOST_RESULT_OF_ARGS)>
 
 #undef BOOST_RESULT_OF_ARGS
 
+#endif // defined(BOOST_HAS_DECLTYPE)
+
 #if BOOST_PP_ITERATION() >= 1 
 
 namespace detail {

include/boost/utility/enable_if.hpp

@@ -1,12 +1,12 @@
 // Boost enable_if library
 
-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.
 
 // Use, modification, and distribution is subject to 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)
 
-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 

include/boost/utility/result_of.hpp

@@ -18,6 +18,9 @@
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
 
 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10
@@ -33,6 +36,7 @@ namespace detail {
 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
 
 template<typename F, typename FArgs, bool HasResultType> struct result_of_impl;
+template<typename F> struct result_of_decltype_impl;
 
 template<typename F>
 struct result_of_void_impl

include/boost/utility/swap.hpp

@@ -0,0 +1,51 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin
+//
+// 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)
+// For more information, see http://www.boost.org
+//
+// Update:
+// 29 June 2008 (Added support for built-in arrays.) Niels Dekker  
+
+
+#ifndef BOOST_UTILITY_SWAP_HPP
+#define BOOST_UTILITY_SWAP_HPP
+
+#include <algorithm> //for std::swap
+#include <cstddef> //for std::size_t
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using std::swap;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  namespace swap_adl_barrier
+  {
+    template<class T>
+    void swap(T& left, T& right)
+    {
+      ::boost_swap_impl::swap_impl(left, right);
+    }
+  }
+
+  using swap_adl_barrier::swap;
+}
+
+#endif

include/boost/utility/value_init.hpp

@@ -5,7 +5,8 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
-// 30 Jan 2008 (Worked around compiler bugs, added initialized_value) Fernando Cacciola, Niels Dekker
+// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
+// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
 //
 #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
@@ -18,6 +19,7 @@
 
 #include <boost/aligned_storage.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/cv_traits.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <cstring>
@@ -75,7 +77,9 @@ class value_initialized
 
     value_initialized & operator=(value_initialized const & arg)
     {
-      this->data() = static_cast<T const &>( arg.data() );
+      // Assignment is only allowed when T is non-const.
+      BOOST_STATIC_ASSERT( ! is_const<T>::value );
+      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
       return *this;
     }
 
@@ -107,7 +111,7 @@ T& get ( value_initialized<T>& x )
 }
 
 
-class initialized_value
+class initialized_value_t
 {
   public :
     
@@ -117,6 +121,8 @@ class initialized_value
     }
 };
 
+initialized_value_t const initialized_value = {} ;
+
 
 } // namespace boost
 

index.html

@@ -21,14 +21,16 @@
 				<a href="compressed_pair.htm">compressed_pair</a><br>
 				<a href="current_function.html">current_function</a><br>
 				<a href="enable_if.html">enable_if</a><br>
-                <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
 				<a href="operators.htm">operators</a><br>
+				<a href="swap.html">swap</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
                 <a href="value_init.htm">value_init</a></p>
 		</blockquote>
 		<hr>
-		<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+		<p>&copy; Copyright Beman Dawes, 2001</p>
         <p>Distributed under the Boost Software License, Version 1.0. (See 
         accompanying file <a href="../../LICENSE_1_0.txt">
         LICENSE_1_0.txt</a> or copy at

operators_test.cpp

@@ -7,6 +7,7 @@
 //  See http://www.boost.org/libs/utility for documentation.
 
 //  Revision History
+//  03 Apr 08 Added convertible_to_bool (Daniel Frey)
 //  01 Oct 01 Added tests for "left" operators
 //            and new grouped operators. (Helmut Zeisel)
 //  20 May 01 Output progress messages.  Added tests for new operator
@@ -43,6 +44,23 @@ namespace
     unsigned char true_value(unsigned char x) { return x; }
     unsigned short true_value(unsigned short x) { return x; }
 
+    // verify the minimum requirements for some operators
+    class convertible_to_bool
+    {
+    private:
+        bool _value;
+
+        typedef bool convertible_to_bool::*unspecified_bool_type;
+
+        void operator!() const;
+
+    public:
+        convertible_to_bool( const bool value ) : _value( value ) {}
+
+        operator unspecified_bool_type() const
+          { return _value ? &convertible_to_bool::_value : 0; }
+    };
+
     // The use of operators<> here tended to obscure
     // interactions with certain compiler bugs
     template <class T>
@@ -54,8 +72,10 @@ namespace
         explicit Wrapped1( T v = T() ) : _value(v) {}
         T value() const { return _value; }
 
-        bool operator<(const Wrapped1& x) const { return _value < x._value; }
-        bool operator==(const Wrapped1& x) const { return _value == x._value; }
+        convertible_to_bool operator<(const Wrapped1& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator==(const Wrapped1& x) const
+          { return _value == x._value; }
         
         Wrapped1& operator+=(const Wrapped1& x)
           { _value += x._value; return *this; }
@@ -97,8 +117,10 @@ namespace
         explicit Wrapped2( T v = T() ) : _value(v) {}
         T value() const { return _value; }
 
-        bool operator<(const Wrapped2& x) const { return _value < x._value; }
-        bool operator==(const Wrapped2& x) const { return _value == x._value; }
+        convertible_to_bool operator<(const Wrapped2& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator==(const Wrapped2& x) const
+          { return _value == x._value; }
         
         Wrapped2& operator+=(const Wrapped2& x)
           { _value += x._value; return *this; }
@@ -123,9 +145,13 @@ namespace
         Wrapped2& operator++()                { ++_value; return *this; }
         Wrapped2& operator--()                { --_value; return *this; }
          
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(U u) const { return _value == u; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
         Wrapped2& operator+=(U u) { _value += u; return *this; }
         Wrapped2& operator-=(U u) { _value -= u; return *this; }
         Wrapped2& operator*=(U u) { _value *= u; return *this; }
@@ -153,7 +179,8 @@ namespace
         explicit Wrapped3( T v = T() ) : _value(v) {}
         T value() const { return _value; }
 
-        bool operator<(const Wrapped3& x) const { return _value < x._value; }
+        convertible_to_bool operator<(const Wrapped3& x) const
+          { return _value < x._value; }
         
     private:
         T _value;
@@ -174,10 +201,13 @@ namespace
         explicit Wrapped4( T v = T() ) : _value(v) {}
         T value() const { return _value; }
 
-        bool operator<(const Wrapped4& x) const { return _value < x._value; }
+        convertible_to_bool operator<(const Wrapped4& x) const
+          { return _value < x._value; }
          
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
 
     private:
         T _value;
@@ -198,11 +228,18 @@ namespace
         Wrapped5(U u) : _value(u) {}
 
         T value() const { return _value; }
-        bool operator<(const Wrapped5& x) const { return _value < x._value; }
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(const Wrapped5& u) const { return _value == u._value; }
-        bool operator==(U u) const { return _value == u; }
+
+        convertible_to_bool operator<(const Wrapped5& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(const Wrapped5& u) const
+          { return _value == u._value; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
         Wrapped5& operator/=(const Wrapped5& u) { _value /= u._value; return *this;}
         Wrapped5& operator/=(U u) { _value /= u; return *this;}
         Wrapped5& operator*=(const Wrapped5& u) { _value *= u._value; return *this;}
@@ -231,11 +268,18 @@ namespace
         Wrapped6(U u) : _value(u) {}
 
         T value() const { return _value; }
-        bool operator<(const Wrapped6& x) const { return _value < x._value; }
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(const Wrapped6& u) const { return _value == u._value; }
-        bool operator==(U u) const { return _value == u; }
+
+        convertible_to_bool operator<(const Wrapped6& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(const Wrapped6& u) const
+          { return _value == u._value; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
         Wrapped6& operator%=(const Wrapped6& u) { _value %= u._value; return *this;}
         Wrapped6& operator%=(U u) { _value %= u; return *this;}
         Wrapped6& operator/=(const Wrapped6& u) { _value /= u._value; return *this;}
@@ -276,10 +320,10 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_CHECK( (x1 < y1) == (x2 < y2) );
-        BOOST_CHECK( (x1 <= y1) == (x2 <= y2) );
-        BOOST_CHECK( (x1 >= y1) == (x2 >= y2) );
-        BOOST_CHECK( (x1 > y1) == (x2 > y2) );
+        BOOST_CHECK( static_cast<bool>(x1 < y1) == static_cast<bool>(x2 < y2) );
+        BOOST_CHECK( static_cast<bool>(x1 <= y1) == static_cast<bool>(x2 <= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 >= y1) == static_cast<bool>(x2 >= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 > y1) == static_cast<bool>(x2 > y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -293,8 +337,8 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_CHECK( (x1 == y1) == (x2 == y2) );
-        BOOST_CHECK( (x1 != y1) == (x2 != y2) );
+        BOOST_CHECK( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
+        BOOST_CHECK( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -614,14 +658,14 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );
 
-    BOOST_CHECK( i2 == i );
-    BOOST_CHECK( i1 != i2 );
-    BOOST_CHECK( i1 <  i2 );
-    BOOST_CHECK( i1 <= i2 );
-    BOOST_CHECK( i <= i2 );
-    BOOST_CHECK( i2 >  i1 );
-    BOOST_CHECK( i2 >= i1 );
-    BOOST_CHECK( i2 >= i );
+    BOOST_CHECK( static_cast<bool>(i2 == i) );
+    BOOST_CHECK( static_cast<bool>(i1 != i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <  i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <= i2) );
+    BOOST_CHECK( static_cast<bool>(i <= i2) );
+    BOOST_CHECK( static_cast<bool>(i2 >  i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i) );
 
     PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
     PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
@@ -653,78 +697,78 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
     
-    BOOST_CHECK( j2 == j );
-    BOOST_CHECK( 2 == j );
-    BOOST_CHECK( j2 == 2 );    
-    BOOST_CHECK( j == j2 );
-    BOOST_CHECK( j1 != j2 );
-    BOOST_CHECK( j1 != 2 );
-    BOOST_CHECK( 1 != j2 );
-    BOOST_CHECK( j1 <  j2 );
-    BOOST_CHECK( 1 <  j2 );
-    BOOST_CHECK( j1 <  2 );
-    BOOST_CHECK( j1 <= j2 );
-    BOOST_CHECK( 1 <= j2 );
-    BOOST_CHECK( j1 <= j );
-    BOOST_CHECK( j <= j2 );
-    BOOST_CHECK( 2 <= j2 );
-    BOOST_CHECK( j <= 2 );
-    BOOST_CHECK( j2 >  j1 );
-    BOOST_CHECK( 2 >  j1 );
-    BOOST_CHECK( j2 >  1 );
-    BOOST_CHECK( j2 >= j1 );
-    BOOST_CHECK( 2 >= j1 );
-    BOOST_CHECK( j2 >= 1 );
-    BOOST_CHECK( j2 >= j );
-    BOOST_CHECK( 2 >= j );
-    BOOST_CHECK( j2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(j2 == j) );
+    BOOST_CHECK( static_cast<bool>(2 == j) );
+    BOOST_CHECK( static_cast<bool>(j2 == 2) );
+    BOOST_CHECK( static_cast<bool>(j == j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j) );
+    BOOST_CHECK( static_cast<bool>(j <= j2) );
+    BOOST_CHECK( static_cast<bool>(2 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j <= 2) );
+    BOOST_CHECK( static_cast<bool>(j2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >  1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j) );
+    BOOST_CHECK( static_cast<bool>(2 >= j) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 2) );
 
-    BOOST_CHECK( (j1 + 2) == 3 );
-    BOOST_CHECK( (1 + j2) == 3 );
+    BOOST_CHECK( static_cast<bool>((j1 + 2) == 3) );
+    BOOST_CHECK( static_cast<bool>((1 + j2) == 3) );
     PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
     
-    BOOST_CHECK( (j + 2) == 5 );
-    BOOST_CHECK( (3 + j2) == 5 );
+    BOOST_CHECK( static_cast<bool>((j + 2) == 5) );
+    BOOST_CHECK( static_cast<bool>((3 + j2) == 5) );
     PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
     
-    BOOST_CHECK( (j - 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j - 1) == 4) );
     PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
     
-    BOOST_CHECK( (j * 2) == 8 );
-    BOOST_CHECK( (4 * j2) == 8 );
+    BOOST_CHECK( static_cast<bool>((j * 2) == 8) );
+    BOOST_CHECK( static_cast<bool>((4 * j2) == 8) );
     PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
     
-    BOOST_CHECK( (j / 2) == 4 );
+    BOOST_CHECK( static_cast<bool>((j / 2) == 4) );
     PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
     
-    BOOST_CHECK( (j % 3) == 1 );
+    BOOST_CHECK( static_cast<bool>((j % 3) == 1) );
     PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
     
     PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
     
-    BOOST_CHECK( (1 | j2 | j) == 7 );
-    BOOST_CHECK( (j1 | 2 | j) == 7 );
-    BOOST_CHECK( (j1 | j2 | 4) == 7 );
+    BOOST_CHECK( static_cast<bool>((1 | j2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | 2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | j2 | 4) == 7) );
     PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
     
-    BOOST_CHECK( (7 & j2) == 2 );
-    BOOST_CHECK( (j & 2) == 2 );
+    BOOST_CHECK( static_cast<bool>((7 & j2) == 2) );
+    BOOST_CHECK( static_cast<bool>((j & 2) == 2) );
     PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
     
-    BOOST_CHECK( (3 ^ j1) == 2 );
-    BOOST_CHECK( (j ^ 1) == 2 );
+    BOOST_CHECK( static_cast<bool>((3 ^ j1) == 2) );
+    BOOST_CHECK( static_cast<bool>((j ^ 1) == 2) );
     PRIVATE_EXPR_TEST( (j = j ^ j1), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = ( j + j1 ) * ( j2 | j1 )), (j.value() == 9) );
 
-    BOOST_CHECK( (j1 << 2) == 4 );
-    BOOST_CHECK( (j2 << 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j1 << 2) == 4) );
+    BOOST_CHECK( static_cast<bool>((j2 << 1) == 4) );
     PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );
 
-    BOOST_CHECK( (j >> 2) == 1 );
-    BOOST_CHECK( (j2 >> 1) == 1 );
+    BOOST_CHECK( static_cast<bool>((j >> 2) == 1) );
+    BOOST_CHECK( static_cast<bool>((j2 >> 1) == 1) );
     PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
     
     cout << "Performed tests on MyLong objects.\n";
@@ -741,14 +785,14 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );
 
-    BOOST_CHECK( k2 == k );
-    BOOST_CHECK( k1 != k2 );
-    BOOST_CHECK( k1 <  k2 );
-    BOOST_CHECK( k1 <= k2 );
-    BOOST_CHECK( k <= k2 );
-    BOOST_CHECK( k2 >  k1 );
-    BOOST_CHECK( k2 >= k1 );
-    BOOST_CHECK( k2 >= k );
+    BOOST_CHECK( static_cast<bool>(k2 == k) );
+    BOOST_CHECK( static_cast<bool>(k1 != k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <  k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <= k2) );
+    BOOST_CHECK( static_cast<bool>(k <= k2) );
+    BOOST_CHECK( static_cast<bool>(k2 >  k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k) );
     
     cout << "Performed tests on MyChar objects.\n";
 
@@ -764,31 +808,31 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
     
-    BOOST_CHECK( l2 == l );
-    BOOST_CHECK( 2 == l );
-    BOOST_CHECK( l2 == 2 );    
-    BOOST_CHECK( l == l2 );
-    BOOST_CHECK( l1 != l2 );
-    BOOST_CHECK( l1 != 2 );
-    BOOST_CHECK( 1 != l2 );
-    BOOST_CHECK( l1 <  l2 );
-    BOOST_CHECK( 1 <  l2 );
-    BOOST_CHECK( l1 <  2 );
-    BOOST_CHECK( l1 <= l2 );
-    BOOST_CHECK( 1 <= l2 );
-    BOOST_CHECK( l1 <= l );
-    BOOST_CHECK( l <= l2 );
-    BOOST_CHECK( 2 <= l2 );
-    BOOST_CHECK( l <= 2 );
-    BOOST_CHECK( l2 >  l1 );
-    BOOST_CHECK( 2 >  l1 );
-    BOOST_CHECK( l2 >  1 );
-    BOOST_CHECK( l2 >= l1 );
-    BOOST_CHECK( 2 >= l1 );
-    BOOST_CHECK( l2 >= 1 );
-    BOOST_CHECK( l2 >= l );
-    BOOST_CHECK( 2 >= l );
-    BOOST_CHECK( l2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(l2 == l) );
+    BOOST_CHECK( static_cast<bool>(2 == l) );
+    BOOST_CHECK( static_cast<bool>(l2 == 2) );
+    BOOST_CHECK( static_cast<bool>(l == l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l) );
+    BOOST_CHECK( static_cast<bool>(l <= l2) );
+    BOOST_CHECK( static_cast<bool>(2 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l <= 2) );
+    BOOST_CHECK( static_cast<bool>(l2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >  1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l) );
+    BOOST_CHECK( static_cast<bool>(2 >= l) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 2) );
     
     cout << "Performed tests on MyShort objects.\n";
     
@@ -807,37 +851,37 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
     
-    BOOST_CHECK( di2 == di );
-    BOOST_CHECK( 2 == di );
-    BOOST_CHECK( di == 2 );
-    BOOST_CHECK( di1 < di2 );
-    BOOST_CHECK( 1 < di2 );
-    BOOST_CHECK( di1 <= di2 );
-    BOOST_CHECK( 1 <= di2 );
-    BOOST_CHECK( di2 > di1 );
-    BOOST_CHECK( di2 > 1 );
-    BOOST_CHECK( di2 >= di1 );
-    BOOST_CHECK( di2 >= 1 );
-    BOOST_CHECK( di1 / di2 == half );
-    BOOST_CHECK( di1 / 2 == half );
-    BOOST_CHECK( 1 / di2 == half );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
-    BOOST_CHECK( di1 * di2 == di2 );
-    BOOST_CHECK( di1 * 2 == di2 );
-    BOOST_CHECK( 1 * di2 == di2 );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
-    BOOST_CHECK( di2 - di1 == di1 );
-    BOOST_CHECK( di2 - 1 == di1 );
-    BOOST_CHECK( 2 - di1 == di1 );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
-    BOOST_CHECK( di1 + di1 == di2 );
-    BOOST_CHECK( di1 + 1 == di2 );
-    BOOST_CHECK( 1 + di1 == di2 );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=1) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=di1) == di2) );
+    BOOST_CHECK( static_cast<bool>(di2 == di) );
+    BOOST_CHECK( static_cast<bool>(2 == di) );
+    BOOST_CHECK( static_cast<bool>(di == 2) );
+    BOOST_CHECK( static_cast<bool>(di1 < di2) );
+    BOOST_CHECK( static_cast<bool>(1 < di2) );
+    BOOST_CHECK( static_cast<bool>(di1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(di2 > di1) );
+    BOOST_CHECK( static_cast<bool>(di2 > 1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= di1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(di1 / di2 == half) );
+    BOOST_CHECK( static_cast<bool>(di1 / 2 == half) );
+    BOOST_CHECK( static_cast<bool>(1 / di2 == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=2) == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=di2) == half) );
+    BOOST_CHECK( static_cast<bool>(di1 * di2 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 * 2 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 * di2 == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=2) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=di2) == di2) );
+    BOOST_CHECK( static_cast<bool>(di2 - di1 == di1) );
+    BOOST_CHECK( static_cast<bool>(di2 - 1 == di1) );
+    BOOST_CHECK( static_cast<bool>(2 - di1 == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=1) == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=di1) == di1) );
+    BOOST_CHECK( static_cast<bool>(di1 + di1 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 + 1 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 + di1 == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=1) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=di1) == di2) );
 
     cout << "Performed tests on MyDoubleInt objects.\n";
 
@@ -854,42 +898,42 @@ test_main( int , char * [] )
 
     PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
     
-    BOOST_CHECK( li2 == li );
-    BOOST_CHECK( 2 == li );
-    BOOST_CHECK( li == 2 );
-    BOOST_CHECK( li1 < li2 );
-    BOOST_CHECK( 1 < li2 );
-    BOOST_CHECK( li1 <= li2 );
-    BOOST_CHECK( 1 <= li2 );
-    BOOST_CHECK( li2 > li1 );
-    BOOST_CHECK( li2 > 1 );
-    BOOST_CHECK( li2 >= li1 );
-    BOOST_CHECK( li2 >= 1 );
-    BOOST_CHECK( li1 % li2 == li1 );
-    BOOST_CHECK( li1 % 2 == li1 );
-    BOOST_CHECK( 1 % li2 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
-    BOOST_CHECK( li1 / li2 == 0 );
-    BOOST_CHECK( li1 / 2 == 0 );
-    BOOST_CHECK( 1 / li2 == 0 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
-    BOOST_CHECK( li1 * li2 == li2 );
-    BOOST_CHECK( li1 * 2 == li2 );
-    BOOST_CHECK( 1 * li2 == li2 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
-    BOOST_CHECK( li2 - li1 == li1 );
-    BOOST_CHECK( li2 - 1 == li1 );
-    BOOST_CHECK( 2 - li1 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
-    BOOST_CHECK( li1 + li1 == li2 );
-    BOOST_CHECK( li1 + 1 == li2 );
-    BOOST_CHECK( 1 + li1 == li2 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=1) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=li1) == li2) );
+    BOOST_CHECK( static_cast<bool>(li2 == li) );
+    BOOST_CHECK( static_cast<bool>(2 == li) );
+    BOOST_CHECK( static_cast<bool>(li == 2) );
+    BOOST_CHECK( static_cast<bool>(li1 < li2) );
+    BOOST_CHECK( static_cast<bool>(1 < li2) );
+    BOOST_CHECK( static_cast<bool>(li1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(li2 > li1) );
+    BOOST_CHECK( static_cast<bool>(li2 > 1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= li1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(li1 % li2 == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 % 2 == li1) );
+    BOOST_CHECK( static_cast<bool>(1 % li2 == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=2) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=li2) == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 / li2 == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 / 2 == 0) );
+    BOOST_CHECK( static_cast<bool>(1 / li2 == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=2) == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=li2) == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 * li2 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 * 2 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 * li2 == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=2) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=li2) == li2) );
+    BOOST_CHECK( static_cast<bool>(li2 - li1 == li1) );
+    BOOST_CHECK( static_cast<bool>(li2 - 1 == li1) );
+    BOOST_CHECK( static_cast<bool>(2 - li1 == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=1) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=li1) == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 + li1 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 + 1 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 + li1 == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=1) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=li1) == li2) );
 
     cout << "Performed tests on MyLongInt objects.\n";
 

ref_test.cpp

@@ -68,11 +68,54 @@ struct ref_wrapper
     }
 };
 
+struct copy_counter {
+  static int count_;
+  copy_counter(copy_counter const& other) {
+    ++count_;
+  }
+  copy_counter() {}
+  static void reset() { count_ = 0; }
+  static int count() { return copy_counter::count_;  }
+};
+
+int copy_counter::count_ = 0;
+
 } // namespace unnamed
 
+template <class T>
+void do_unwrap(T t) {
+
+  /* typename unwrap_reference<T>::type& lt = */
+  unwrap_ref(t);
+
+}
+
+void unwrap_test() {
+
+  int i = 3;
+  const int ci = 2;
+
+  do_unwrap(i);
+  do_unwrap(ci);
+  do_unwrap(ref(i));
+  do_unwrap(cref(ci));
+  do_unwrap(ref(ci));
+
+  copy_counter cc;
+  BOOST_CHECK(cc.count() == 0);
+
+  do_unwrap(cc);
+  do_unwrap(ref(cc));
+  do_unwrap(cref(cc));
+
+  BOOST_CHECK(cc.count() == 1);
+  BOOST_CHECK(unwrap_ref(ref(cc)).count() == 1); 
+}
+
 int test_main(int, char * [])
 {
     ref_wrapper<int>::test(1);
     ref_wrapper<int const>::test(1);
+    unwrap_test();
     return 0;
 }

swap.html

@@ -0,0 +1,94 @@
+?<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Boost: Swap Documentation</title>
+   </head>
+  <body>
+    <!-- Page header -->
+    <img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
+    <h1>Swap</h1>
+    
+    <p>
+      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
+    </p>
+     
+    <!-- Intoduction -->
+    <p>
+      The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
+    </p>
+    
+    <!-- Rationale -->
+    <h2>Rationale</h2>
+    <p>
+      The generic <tt>std::swap</tt> 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<sup><a href="#ref1">1</a></sup>).</p>
+    <p>
+      The alternative to using argument dependent lookup in this situation is to provide a template specialization of std::swap for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
+    </p>
+    <p>
+      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> doesn't yet do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been well-received by the Library Working Group of the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.      
+    </p>
+    
+    <!-- Exception Safety -->
+    <h2>Exception Safety</h2>
+    <p>
+      <tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
+    </p>
+    
+    <!-- Requirements -->
+    <h2>Requirements</h2>
+    <p>Either:</p>
+    <ul>      
+      <li>T must be assignable</li>
+      <li>T must be copy constructible</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A function with the signature <tt>swap(T&,T&)</tt> is available via argument dependent lookup</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A template specialization of std::swap exists for T</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>T is a built-in array of swappable elements</li>
+    </ul>
+
+    
+    <!-- Portability -->
+    <h2>Portability</h2>
+    <p>
+      Several older compilers do not support argument dependent lookup <20> on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
+    </p>
+    
+    <!-- Credits -->
+    <h2>Credits</h2>
+    <ul>
+      <li>
+        <em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
+      </li>
+      <li>
+        <em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
+      </li>
+      <li>
+        <em>Steven Wanatabe</em> - for the idea to use a barrier namespace, enabling the function to have the name '<tt>swap</tt>' without introducing ambiguity or infinite recursion
+      </li>      
+    </ul>
+
+    <!-- References -->
+    <hr/>
+    <p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
+    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#809">LWG issue 809 (std::swap should be overloaded for array types)</a></p>
+
+    <!-- Copyright info -->    
+    <hr/>
+    <p>Revised: 3 July 2008</p>
+    <p>
+      Copyright 2007, 2008 Joseph Gauterin. Use, modification, and distribution are subject to the Boost Software License, Version 1.0.
+      (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)
+    </p>
+    
+  </body>
+</html>

swap/test/Jamfile.v2

@@ -0,0 +1,53 @@
+# Copyright (c) 2007, 2008 Joseph Gauterin
+#
+# 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)
+
+# bring in rules for testing
+import testing ;
+
+test-suite utility/swap
+    :
+    [ compile root_header_1.cpp                                  ]
+    [ compile root_header_2.cpp                                  ]
+    [ compile lib_header_1.cpp                                   ]
+    [ compile lib_header_2.cpp                                   ]
+    [ compile mixed_headers_1.cpp                                ]
+    [ compile mixed_headers_2.cpp                                ]
+    [ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static             ]
+    [ run specialized_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static  ]
+    [ run specialized_in_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
+    [ run specialized_in_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static  ]
+    [ run specialized_in_std.cpp ../../../test/build//boost_test_exec_monitor/<link>static    ]
+    [ run swap_arrays.cpp ../../../test/build//boost_test_exec_monitor/<link>static    ]
+    ;
+    
+
+# Copyright (c) 2007, 2008 Joseph Gauterin
+#
+# 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)
+
+# bring in rules for testing
+import testing ;
+
+test-suite utility/swap
+    :
+    [ compile root_header_1.cpp                                  ]
+    [ compile root_header_2.cpp                                  ]
+    [ compile lib_header_1.cpp                                   ]
+    [ compile lib_header_2.cpp                                   ]
+    [ compile mixed_headers_1.cpp                                ]
+    [ compile mixed_headers_2.cpp                                ]
+    [ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static             ]
+    [ run specialized_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static  ]
+    [ run specialized_in_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
+    [ run specialized_in_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static  ]
+    [ run specialized_in_std.cpp ../../../test/build//boost_test_exec_monitor/<link>static    ]
+    [ run swap_arrays.cpp ../../../test/build//boost_test_exec_monitor/<link>static    ]
+    ;
+    
+
+

swap/test/lib_header_1.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#include <boost/utility/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#include <boost/utility/swap.hpp>

swap/test/lib_header_2.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header include guards work correctly
+
+#include <boost/utility/swap.hpp>
+#include <boost/utility/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header include guards work correctly
+
+#include <boost/utility/swap.hpp>
+#include <boost/utility/swap.hpp>

swap/test/mixed_headers_1.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap headers work when both are included
+
+#include <boost/swap.hpp>
+#include <boost/utility/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap headers work when both are included
+
+#include <boost/swap.hpp>
+#include <boost/utility/swap.hpp>

swap/test/mixed_headers_2.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap headers work when both are included
+
+#include <boost/utility/swap.hpp>
+#include <boost/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap headers work when both are included
+
+#include <boost/utility/swap.hpp>
+#include <boost/swap.hpp>

swap/test/primitive.cpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+int test_main(int, char*[])
+{
+  int object1 = 1;
+  int object2 = 2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,2);
+  BOOST_CHECK_EQUAL(object2,1);
+
+  return 0;
+}
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+int test_main(int, char*[])
+{
+  int object1 = 1;
+  int object2 = 2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,2);
+  BOOST_CHECK_EQUAL(object2,1);
+
+  return 0;
+}

swap/test/root_header_1.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#include <boost/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#include <boost/swap.hpp>

swap/test/root_header_2.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header include guards work correctly
+
+#include <boost/swap.hpp>
+#include <boost/swap.hpp>
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header include guards work correctly
+
+#include <boost/swap.hpp>
+#include <boost/swap.hpp>

swap/test/specialized_in_boost.cpp

@@ -0,0 +1,72 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace boost
+namespace boost
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace boost
+namespace boost
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  boost::swap_test_class object1;
+  boost::swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);
+
+  return 0;
+}
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace boost
+namespace boost
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace boost
+namespace boost
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  boost::swap_test_class object1;
+  boost::swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);
+
+  return 0;
+}

swap/test/specialized_in_global.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+//Provide swap function in gloabl namespace
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+int test_main(int, char*[])
+{
+  swap_test_class object1;
+  swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+//Provide swap function in gloabl namespace
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+int test_main(int, char*[])
+{
+  swap_test_class object1;
+  swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}

swap/test/specialized_in_other.cpp

@@ -0,0 +1,72 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace other
+namespace other
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace other
+namespace other
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  other::swap_test_class object1;
+  other::swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
+
+  return 0;
+}
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace other
+namespace other
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace other
+namespace other
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  other::swap_test_class object1;
+  other::swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
+
+  return 0;
+}

swap/test/specialized_in_std.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+
+//Provide swap function in namespace std
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  swap_test_class object1;
+  swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+
+//Provide swap function in namespace std
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  swap_test_class object1;
+  swap_test_class object2;
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}

swap/test/swap_arrays.cpp

@@ -0,0 +1,78 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+
+int test_main(int, char*[])
+{
+  const std::size_t dimension = 7;
+
+  swap_test_class array1[dimension];
+  swap_test_class array2[dimension];
+  boost::swap(array1, array2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), dimension);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  swap_test_class::reset();
+
+  const std::size_t firstDimension = 3;
+  const std::size_t secondDimension = 4;
+
+  swap_test_class two_d_array1[firstDimension][secondDimension];
+  swap_test_class two_d_array2[firstDimension][secondDimension];
+  boost::swap(two_d_array1, two_d_array1);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), firstDimension*secondDimension);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// 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/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+
+int test_main(int, char*[])
+{
+  const std::size_t dimension = 7;
+
+  swap_test_class array1[dimension];
+  swap_test_class array2[dimension];
+  boost::swap(array1, array2);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), dimension);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  swap_test_class::reset();
+
+  const std::size_t firstDimension = 3;
+  const std::size_t secondDimension = 4;
+
+  swap_test_class two_d_array1[firstDimension][secondDimension];
+  swap_test_class two_d_array2[firstDimension][secondDimension];
+  boost::swap(two_d_array1, two_d_array1);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), firstDimension*secondDimension);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}

swap/test/swap_test_class.hpp

@@ -0,0 +1,171 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#ifndef BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+#define BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+
+
+class swap_test_class
+{
+public:
+  swap_test_class()
+  {
+    ++constructCount();
+  }
+
+  ~swap_test_class()
+  {
+    ++destructCount();
+  }
+
+  swap_test_class(const swap_test_class&)
+  {
+    ++copyCount();
+    ++destructCount();
+  }
+
+  swap_test_class& operator=(const swap_test_class&)
+  {
+    ++copyCount();
+    return *this;
+  }
+
+  void swap(swap_test_class& other)
+  {
+    ++swapCount();
+  }
+
+
+  static unsigned int swap_count(){ return swapCount(); }
+  static unsigned int copy_count(){ return copyCount(); }
+  static unsigned int construct_count(){ return constructCount(); }
+  static unsigned int destruct_count(){ return destructCount(); }
+
+  static void reset()
+  {
+    swapCount() = 0;
+    copyCount() = 0;    
+    constructCount() = 0;
+    destructCount() = 0;
+  }
+
+private:
+  static unsigned int& swapCount()
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& copyCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& constructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& destructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+};
+
+#endif
+
+// Copyright (c) 2007 Joseph Gauterin
+//
+// 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 the swap header compiles as a standalone translation unit
+
+#ifndef BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+#define BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+
+
+class swap_test_class
+{
+public:
+  swap_test_class()
+  {
+    ++constructCount();
+  }
+
+  ~swap_test_class()
+  {
+    ++destructCount();
+  }
+
+  swap_test_class(const swap_test_class&)
+  {
+    ++copyCount();
+    ++destructCount();
+  }
+
+  swap_test_class& operator=(const swap_test_class&)
+  {
+    ++copyCount();
+    return *this;
+  }
+
+  void swap(swap_test_class& other)
+  {
+    ++swapCount();
+  }
+
+
+  static unsigned int swap_count(){ return swapCount(); }
+  static unsigned int copy_count(){ return copyCount(); }
+  static unsigned int construct_count(){ return constructCount(); }
+  static unsigned int destruct_count(){ return destructCount(); }
+
+  static void reset()
+  {
+    swapCount() = 0;
+    copyCount() = 0;    
+    constructCount() = 0;
+    destructCount() = 0;
+  }
+
+private:
+  static unsigned int& swapCount()
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& copyCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& constructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& destructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+};
+
+#endif
+
+

test/result_of_test.cpp

@@ -11,35 +11,101 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
-struct int_result_type { typedef int result_type; };
+struct int_result_type
+{
+  typedef int result_type;
+  result_type operator()(float);
+};
 
 struct int_result_of
 {
   template<typename F> struct result { typedef int type; };
+  result<int_result_of(double)>::type operator()(double);
+  result<const int_result_of(double)>::type operator()(double) const;
+  result<int_result_of()>::type operator()();
+  result<volatile int_result_of()>::type operator()() volatile;
 };
 
-struct int_result_type_and_float_result_of
+struct int_result_type_and_float_result_of_and_char_return
 {
   typedef int result_type;
   template<typename F> struct result { typedef float type; };
+  char operator()(char);
 };
 
 template<typename T>
-struct int_result_type_template { typedef int result_type; };
+struct int_result_type_template
+{
+  typedef int result_type;
+  result_type operator()(float);
+};
 
 template<typename T>
 struct int_result_of_template
 {
   template<typename F> struct result;
   template<typename This, typename That> struct result<This(That)> { typedef int type; };
+  typename result<int_result_of_template<T>(double)>::type operator()(double);
+  typename result<const int_result_of_template<T>(double)>::type operator()(double) const;
+  typename result<int_result_of_template<T>(double)>::type operator()();
+  typename result<volatile int_result_of_template<T>(double)>::type operator()() volatile;
 };
 
 template<typename T>
-struct int_result_type_and_float_result_of_template
+struct int_result_type_and_float_result_of_and_char_return_template
 {
   typedef int result_type;
   template<typename F> struct result;
   template<typename This, typename That> struct result<This(That)> { typedef float type; };
+  char operator()(char);
+};
+
+struct result_of_member_function_template
+{
+  template<typename F> struct result;
+
+  template<typename This, typename That> struct result<This(That)> { typedef That type; };
+  template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);
+
+  template<typename This, typename That> struct result<const This(That)> { typedef const That type; };
+  template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;
+
+  template<typename This, typename That> struct result<volatile This(That)> { typedef volatile That type; };
+  template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;
+
+  template<typename This, typename That> struct result<const volatile This(That)> { typedef const volatile That type; };
+  template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;
+
+  template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
+  template<class T> typename result<result_of_member_function_template(T &, T)>::type operator()(T &, T);
+
+  template<typename This, typename That> struct result<This(That const &, That)> { typedef That const & type; };
+  template<class T> typename result<result_of_member_function_template(T const &, T)>::type operator()(T const &, T);
+
+  template<typename This, typename That> struct result<This(That volatile &, That)> { typedef That volatile & type; };
+  template<class T> typename result<result_of_member_function_template(T volatile &, T)>::type operator()(T volatile &, T);
+
+  template<typename This, typename That> struct result<This(That const volatile &, That)> { typedef That const volatile & type; };
+  template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
+};
+
+struct no_result_type_or_result_of
+{
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
+};
+
+template<typename T>
+struct no_result_type_or_result_of_template
+{
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
 };
 
 struct X {};
@@ -60,16 +126,37 @@ int main()
 
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_template<void>(float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of_template<void>(double)>::type, int>::value));
+
+  // Prior to decltype, result_of could not deduce the return type
+  // nullary function objects unless they exposed a result_type.
+#if defined(BOOST_HAS_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, int>::value));
+#else
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_template<void>(char)>::type, int>::value));
+#endif
+
+  // Prior to decltype, result_of ignored a nested result<> if
+  // result_type was defined. After decltype, result_of deduces the
+  // actual return type of the function object, ignoring both
+  // result<> and result_type.
+#if defined(BOOST_HAS_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
+#else
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
+#endif
+
   BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value)); 
@@ -81,5 +168,27 @@ int main()
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value)); 
   BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(void)>::type, int>::value));
 
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, const double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
+
+#if defined(BOOST_HAS_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of(void)>::type, const unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of_template<void>(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of_template<void>(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of_template<void>(void)>::type, const unsigned short>::value));
+#endif
+
   return 0;
 }

utility.htm

@@ -152,11 +152,13 @@ void f() {
                 ...,t<em>N</em>)</code>. The implementation permits
                 the type <code>F</code> to be a function pointer,
                 function reference, member function pointer, or class
-                type. When <code>F</code> is a class type with a
-                member type <code>result_type</code>,
+                type.</p> <p>If your compiler does not support
+                <code>decltype</code>, then when <code>F</code> is a
+                class type with a member type <code>result_type</code>,
                 <code>result_of&lt;F(T1, T2, ...,
                 T<em>N</em>)&gt;</code> is
-                <code>F::result_type</code>. Otherwise,
+                <code>F::result_type</code>. When <code>F</code>
+                does not contain <code>result_type</code>, 
                 <code>result_of&lt;F(T1, T2, ...,
                 T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
                 T2, ..., T<em>N</em>)&gt;::type</code> when

value_init.htm

@@ -28,12 +28,12 @@
 </ul>
                    
 <dl class="page-index">
-  <dt><a href="#types">Types</a></dt>
+  <dt><a href="#types">Types and objects</a></dt>
 </dl>
                    
 <ul>
           <li><a href="#val_init"><code>template class value_initialized&lt;T&gt;</code></a></li>
-          <li><a href="#initialized_value"><code>class initialized_value</code></a></li>
+          <li><a href="#initialized_value"><code>initialized_value</code></a></li>
                    
 </ul>
               <a href="#acknowledgements">Acknowledgements</a><br>
@@ -53,7 +53,7 @@ union and class   types.
 Moreover, <code>value_initialized</code> offers a workaround to various
 compiler issues regarding value-initialization.
 
-Furthermore a convenience class, <code>initialized_value</code> is provided,
+Furthermore, a <code>const</code> object, <code>initialized_value</code> is provided,
 to avoid repeating the type name when retrieving the value from a
 <code>value_initialized&lt;T&gt;</code> object.
 <br>
@@ -123,12 +123,12 @@ constructed by the following declaration:
 </pre>
 </p>
 <p>
-The convenience class <a href="#initialized_value"><code>initialized_value</code></a>
+The <code>const</code> object <a href="#initialized_value"><code>initialized_value</code></a>
 allows value-initializing a variable as follows:
 <pre>
-  T var = initialized_value();
+  T var = initialized_value ;
 </pre>
-This form of initialization is also very similar to <code>T4 var4 = T4()</code>,
+This form of initialization is semantically equivalent to <code>T4 var4 = T4()</code>,
 but robust against the aforementioned compiler issues.
 
 </p>
@@ -249,7 +249,7 @@ offer a workaround to these issues: <code>value_initialized</code> will now clea
 its internal data, prior to constructing the object that it contains.
 </p>
                    
-<h2><a name="types"></a>Types</h2>
+<h2><a name="types"></a>Types and objects</h2>
                    
 <h2><a name="val_init"><code>template class value_initialized&lt;T&gt;</code></a></h2>
                    
@@ -312,19 +312,22 @@ the wrapped object is always performed with the <code>get()</code> idiom:</p>
                    
 <pre>value_initialized&lt;int&gt; x ;<br>get(x) = 1 ; // OK<br><br>value_initialized&lt;int const&gt; cx ;<br>get(x) = 1 ; // ERROR: Cannot modify a const object<br><br>value_initialized&lt;int&gt; const x_c ;<br>get(x_c) = 1 ; // ERROR: Cannot modify a const object<br><br>value_initialized&lt;int const&gt; const cx_c ;<br>get(cx_c) = 1 ; // ERROR: Cannot modify a const object<br></pre>
 
-<h2><a name="initialized_value"><code>class initialized_value</code></a></h2>
+<h2><a name="initialized_value"><code>initialized_value</code></a></h2>
 
 <pre>
 namespace boost {
-class initialized_value
+class initialized_value_t
 {
   public :
     template &lt;class T&gt; operator T() const ;
 };
+
+initialized_value_t const initialized_value = {} ;
+
 } // namespace boost
 </pre>
 
-The class <code>initialized_value</code> provides a convenient way to get
+<code>initialized_value</code> provides a convenient way to get
 an initialized value: its conversion operator provides an appropriate
 <em>value-initialized</em> object for any CopyConstructible type.
 
@@ -343,7 +346,7 @@ is rather short now (<code>T</code>), but could of course be
 more like <code>Namespace::Template&lt;Arg&gt;::Type</code>.
 Instead, one could use <code>initialized_value</code> as follows:
 <pre>
-  T var = initialized_value();
+  T var = initialized_value ;
 </pre>
                     
 <h3><a name="references">References</a></h3>
@@ -368,13 +371,15 @@ Special thanks to Bj&ouml;rn Karlsson who carefully edited and completed this do
 <p>value_initialized was reimplemented by Fernando Cacciola and Niels Dekker
 for Boost release version 1.35 (2008), offering a workaround to various compiler issues.
      </p>
+<p>initialized_value was written by Niels Dekker, and added to Boost release version 1.36 (2008).
+     </p>
 <p>Developed by <a href="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</a>,
      the latest version of this file can be found at <a
  href="http://www.boost.org">www.boost.org</a>.
      </p>
                     
 <hr>          
-<p>Revised 16 January 2008</p>
+<p>Revised 23 May 2008</p>
                    
 <p>&copy; Copyright Fernando Cacciola, 2002, 2008.</p>
                    

value_init_test.cpp

@@ -7,7 +7,8 @@
 // Test program for "boost/utility/value_init.hpp"
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
-// 19 Jan 2008 (Added tests regarding compiler issues and initialized_value) Fernando Cacciola, Niels Dekker
+// 15 Jan 2008 (Added tests regarding compiler issues) Fernando Cacciola, Niels Dekker
+// 23 May 2008 (Added tests regarding initialized_value) Niels Dekker
 
 #include <cstring>  // For memcmp.
 #include <iostream>
@@ -183,7 +184,7 @@ struct CopyFunctionCallTester
 template<class T>
 void check_initialized_value ( T const& y )
 {
-  T initializedValue = boost::initialized_value() ;
+  T initializedValue = boost::initialized_value ;
   BOOST_CHECK ( y == initializedValue ) ;
 }
 
@@ -305,6 +306,10 @@ int test_main(int, char **)
   boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
   BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
 
+  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes2;
+  valueInitializedArrayOfBytes2 = valueInitializedArrayOfBytes;
+  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
+
   boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
   BOOST_CHECK ( ! get(copyFunctionCallTester1).is_copy_constructed);
   BOOST_CHECK ( ! get(copyFunctionCallTester1).is_assignment_called);