Release 1.37.0

[SVN r51178]
This html was outdated; changed to forward to throw_exception.html documentation from Boost Exception
2025-10-06 22:10:54 +02:00 · 2009-02-10 13:14:42 +00:00 · 2009-01-29 19:14:05 +00:00 · 2009-01-24 18:57:20 +00:00 · 2008-12-09 18:21:25 +00:00 · 2008-11-27 19:37:39 +00:00
23 changed files with 543 additions and 647 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,31 @@
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    assert.hpp
+    call_traits.hpp
+    checked_delete.hpp
+    compressed_pair.hpp
+    current_function.hpp
+    operators.hpp
+    throw_exception.hpp
+    utility.hpp
+    utility
+)
+
+# Add a library target to the build system
+boost_library_project(
+  utility
+  #  SRCDIRS 
+  TESTDIRS  test
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  DESCRIPTION  "Various small utilities for C++ programming."
+  MODULARIZED 
+  AUTHORS  "David Abrahams <dave -at- boostpro.com>"
+           "Brad King"
+           "Douglas Gregor <doug.gregor -at- gmail.com>"
+  #  MAINTAINERS 
+)
+
+
--- a/in_place_factories.html
+++ b/in_place_factories.html
@@ -99,7 +99,7 @@ directly to the container:</p>
 <H2><A NAME="framework"></A>Framework</H2>
 <p>
 This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
-the entire set of constructor overloads ftom the contained type. It also allows the container to remove the CopyConstuctible
+the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible
 requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
 The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
 Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
@@ -293,4 +293,4 @@ the latest version of this file can be found at <A
 HREF="http://www.boost.org">www.boost.org</A>, and the boost
 <A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
 </BODY>
-</HTML>
+</HTML>
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@@ -8,9 +8,6 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

 //  Revision History
-//  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
-//  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
@@ -127,34 +124,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 !static_cast<bool>(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 !(x > y); }
+     friend bool operator>=(const T& x, const U& y) { return !(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 !static_cast<bool>(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 !(y < x); }
+     friend bool operator>=(const U& x, const T& y) { return !(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 !static_cast<bool>(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
+     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
+     friend bool operator>=(const T& x, const T& y) { return !(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 !static_cast<bool>(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
+     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
+     friend bool operator!=(const T& y, const U& x) { return !(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 !static_cast<bool>(x == y); }
+     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
 };

 // A macro which produces "name_2left" from "name".
@@ -359,7 +356,7 @@ struct equivalent2 : B
 {
  friend bool operator==(const T& x, const U& y)
  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
+    return !(x < y) && !(x > y);
  }
 };

@@ -368,7 +365,7 @@ struct equivalent1 : B
 {
  friend bool operator==(const T&x, const T&y)
  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
+    return !(x < y) && !(y < x);
  }
 };

@@ -376,17 +373,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 static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+    { return (x < y) || (x == y); }
  friend bool operator>=(const T& x, const U& y)
-    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
+    { return (x > y) || (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 static_cast<bool>(y > x) || static_cast<bool>(y == x); }
+    { return (y > x) || (y == x); }
  friend bool operator>=(const U& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
+    { return (y < x) || (y == x); }
 };

 template <class T, class B = ::boost::detail::empty_base<T> >
@@ -395,9 +392,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 static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+    { return (x < y) || (x == y); }
  friend bool operator>=(const T& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
+    { return (y < x) || (x == y); }
 };

 //  Combined operator classes (contributed by Daryle Walker) ----------------//
@@ -583,35 +580,7 @@ struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct euclidean_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct euclidean_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidean_ring_operators2
-    : totally_ordered2<T, U
-    , euclidean_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidean_ring_operators1
-    : totally_ordered1<T
-    , euclidean_ring_operators1<T, B
-      > > {};
-
+      
 template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct input_iteratable
    : equality_comparable1<T
@@ -868,8 +837,6 @@ BOOST_OPERATOR_TEMPLATE(field_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
 BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
 BOOST_OPERATOR_TEMPLATE2(input_iteratable)
 BOOST_OPERATOR_TEMPLATE1(output_iteratable)
 BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@@ -173,12 +173,6 @@ 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
--- a/include/boost/swap.hpp
+++ b/include/boost/swap.hpp
@@ -7,6 +7,6 @@
 #ifndef BOOST_SWAP_HPP
 #define BOOST_SWAP_HPP

-#include "./utility/swap.hpp"
+#include "boost/utility/swap.hpp"

 #endif
--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@@ -10,47 +10,6 @@
 # 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<
-            typename remove_cv<F>::type, 
-            typename remove_cv<F>::type(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
@@ -62,22 +21,11 @@ public:
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : mpl::if_<
-          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
-        , boost::detail::result_of_impl<
-            typename remove_cv<F>::type, 
-            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS), 
-            (boost::detail::has_result_type<F>::value)>
-        , boost::detail::result_of_impl<
-            F,
-            F(BOOST_RESULT_OF_ARGS), 
-            (boost::detail::has_result_type<F>::value)> >::type { };
+    : boost::detail::result_of_impl<F, F(BOOST_RESULT_OF_ARGS), (boost::detail::has_result_type<F>::value)> {};
 #endif

 #undef BOOST_RESULT_OF_ARGS

-#endif // defined(BOOST_HAS_DECLTYPE)
-
 #if BOOST_PP_ITERATION() >= 1 

 namespace detail {
--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@@ -10,18 +10,13 @@
 #define BOOST_RESULT_OF_HPP

 #include <boost/config.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp> 
-#include <boost/preprocessor/punctuation/comma_if.hpp> 
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
+#include <boost/type_traits/ice.hpp>
+#include <boost/type.hpp>
+#include <boost/preprocessor.hpp>
 #include <boost/detail/workaround.hpp>
 #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>
-#include <boost/type_traits/remove_cv.hpp>

 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10
@@ -37,7 +32,6 @@ 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
@@ -57,11 +51,6 @@ struct result_of_void_impl<R (&)(void)>
  typedef R type;
 };

-// Determine the return type of a function pointer or pointer to member.
-template<typename F, typename FArgs>
-struct result_of_pointer
-  : result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
-
 template<typename F, typename FArgs>
 struct result_of_impl<F, FArgs, true>
 {
--- a/index.html
+++ b/index.html
@@ -24,7 +24,6 @@
            <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>
--- a/module.cmake
+++ b/module.cmake
@@ -0,0 +1 @@
+boost_module(utility DEPENDS iterator exception detail )
--- a/operators.htm
+++ b/operators.htm
@@ -1420,9 +1420,9 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "euclidean_ring_operators1">euclidean_ring_operators&lt;T&gt;</a></code><br>
+        "euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code><br>

-         <code>euclidean_ring_operators1&lt;T&gt;</code></td>
+         <code>euclidian_ring_operators1&lt;T&gt;</code></td>

        <td>
          <ul>
@@ -1439,9 +1439,9 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "euclidean_ring_operators2">euclidean_ring_operators&lt;T,
+        "euclidian_ring_operators2">euclidian_ring_operators&lt;T,
        U&gt;</a></code><br>
-         <code>euclidean_ring_operators2&lt;T, U&gt;</code></td>
+         <code>euclidian_ring_operators2&lt;T, U&gt;</code></td>

        <td>
          <ul>
@@ -1464,14 +1464,14 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "ordered_euclidean_ring_operators1">ordered_euclidean_ring_operators&lt;T&gt;</a></code><br>
+        "ordered_euclidian_ring_operators1">ordered_euclidian_ring_operators&lt;T&gt;</a></code><br>

-         <code>ordered_euclidean_ring_operators1&lt;T&gt;</code></td>
+         <code>ordered_euclidian_ring_operators1&lt;T&gt;</code></td>

        <td>
          <ul>
            <li><code><a href=
-            "#euclidean_ring_operators1">euclidean_ring_operators&lt;T&gt;</a></code></li>
+            "#euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code></li>

            <li><code><a href=
            "#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
@@ -1481,14 +1481,14 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "ordered_euclidean_ring_operators2">ordered_euclidean_ring_operators&lt;T,
+        "ordered_euclidian_ring_operators2">ordered_euclidian_ring_operators&lt;T,
        U&gt;</a></code><br>
-         <code>ordered_euclidean_ring_operators2&lt;T, U&gt;</code></td>
+         <code>ordered_euclidian_ring_operators2&lt;T, U&gt;</code></td>

        <td>
          <ul>
            <li><code><a href=
-            "#euclidean_ring_operators2">euclidean_ring_operators&lt;T,
+            "#euclidian_ring_operators2">euclidian_ring_operators&lt;T,
            U&gt;</a></code></li>

            <li><code><a href="#totally_ordered2">totally_ordered&lt;T,
@@ -1498,15 +1498,6 @@ T operator+( T lhs, const T&amp; rhs )
      </tr>
    </table>

-    <h4>Spelling: euclidean vs. euclidian</h4>
-
-    <p>Older versions of the Boost.Operators library used
-    &quot;<code>euclidian</code>&quot;, but it was pointed out that
-    &quot;<code>euclidean</code>&quot; is the more common spelling.
-    To be compatible with older version, the library now supports
-    both spellings.
-    </p>
-
    <h3><a name="ex_oprs">Example</a> Templates</h3>

    <p>The arithmetic operator class templates <code><a href=
@@ -1585,8 +1576,9 @@ T operator+( T lhs, const T&amp; rhs )

    <p>The <cite><a href="operators_test.cpp">operators_test.cpp</a></cite>
    program demonstrates the use of the arithmetic operator templates, and
-    can also be used to verify correct operation. Check the compiler status
-    report for the test results with selected platforms.</p>
+    can also be used to verify correct operation. Check the <a href=
+    "../../status/compiler_status.html">compiler status report</a> for the
+    test results with selected platforms.</p>

    <h2><a name="deref">Dereference</a> Operators and Iterator Helpers</h2>

@@ -2030,7 +2022,7 @@ public:
 </pre>
    </blockquote>

-    <p>Check the <a href="../../status/compiler_status.html">compiler status
+    <p>Check the <a href="http://www.boost.org/development/testing.html">compiler status
    report</a> for the test results with selected platforms.</p>
    <hr>

@@ -2127,10 +2119,10 @@ public:
    backward-compatible.</p>
    <hr>

-    <p>Revised: 7 Aug 2008</p>
+    <p>Revised: 29 Oct 2004</p>

    <p>Copyright &copy; Beman Dawes, David Abrahams, 1999-2001.</p>
-    <p>Copyright &copy; Daniel Frey, 2002-2008.</p>
+    <p>Copyright &copy; Daniel Frey, 2002-2004.</p>
    <p>Use, modification, and distribution is subject to the Boost Software 
    License, Version 1.0. (See accompanying file
    <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
--- a/operators_test.cpp
+++ b/operators_test.cpp
@@ -7,7 +7,6 @@
 //  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
@@ -44,23 +43,6 @@ 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>
@@ -72,10 +54,8 @@ namespace
        explicit Wrapped1( T v = T() ) : _value(v) {}
        T value() const { return _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; }
+        bool operator<(const Wrapped1& x) const { return _value < x._value; }
+        bool operator==(const Wrapped1& x) const { return _value == x._value; }
        
        Wrapped1& operator+=(const Wrapped1& x)
          { _value += x._value; return *this; }
@@ -117,10 +97,8 @@ namespace
        explicit Wrapped2( T v = T() ) : _value(v) {}
        T value() const { return _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; }
+        bool operator<(const Wrapped2& x) const { return _value < x._value; }
+        bool operator==(const Wrapped2& x) const { return _value == x._value; }
        
        Wrapped2& operator+=(const Wrapped2& x)
          { _value += x._value; return *this; }
@@ -145,13 +123,9 @@ namespace
        Wrapped2& operator++()                { ++_value; return *this; }
        Wrapped2& operator--()                { --_value; return *this; }
         
-        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; }
-
+        bool operator<(U u) const { return _value < u; }
+        bool operator>(U u) const { return _value > u; }
+        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; }
@@ -179,8 +153,7 @@ namespace
        explicit Wrapped3( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        convertible_to_bool operator<(const Wrapped3& x) const
-          { return _value < x._value; }
+        bool operator<(const Wrapped3& x) const { return _value < x._value; }
        
    private:
        T _value;
@@ -201,13 +174,10 @@ namespace
        explicit Wrapped4( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        convertible_to_bool operator<(const Wrapped4& x) const
-          { return _value < x._value; }
+        bool operator<(const Wrapped4& 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; }
+        bool operator<(U u) const { return _value < u; }
+        bool operator>(U u) const { return _value > u; }

    private:
        T _value;
@@ -228,18 +198,11 @@ namespace
        Wrapped5(U u) : _value(u) {}

        T value() const { return _value; }
-
-        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; }
-
+        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; }
        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;}
@@ -258,8 +221,8 @@ namespace
    // U must be convertible to T
    template <class T, class U>
    class Wrapped6
-        : boost::ordered_euclidean_ring_operators2<Wrapped6<T, U>, U>
-        , boost::ordered_euclidean_ring_operators1<Wrapped6<T, U> >
+        : boost::ordered_euclidian_ring_operators2<Wrapped6<T, U>, U>
+        , boost::ordered_euclidian_ring_operators1<Wrapped6<T, U> >
    {
    public:
        explicit Wrapped6( T v = T() ) : _value(v) {}
@@ -268,18 +231,11 @@ namespace
        Wrapped6(U u) : _value(u) {}

        T value() const { return _value; }
-
-        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; }
-
+        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; }
        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;}
@@ -320,10 +276,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( 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) );
+        BOOST_CHECK( (x1 < y1) == (x2 < y2) );
+        BOOST_CHECK( (x1 <= y1) == (x2 <= y2) );
+        BOOST_CHECK( (x1 >= y1) == (x2 >= y2) );
+        BOOST_CHECK( (x1 > y1) == (x2 > y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@@ -337,8 +293,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( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
-        BOOST_CHECK( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
+        BOOST_CHECK( (x1 == y1) == (x2 == y2) );
+        BOOST_CHECK( (x1 != y1) == (x2 != y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@@ -658,14 +614,14 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );

-    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) );
+    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 );

    PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
    PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
@@ -697,78 +653,78 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (j = j2), (j.value() == 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( 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>((j1 + 2) == 3) );
-    BOOST_CHECK( static_cast<bool>((1 + j2) == 3) );
+    BOOST_CHECK( (j1 + 2) == 3 );
+    BOOST_CHECK( (1 + j2) == 3 );
    PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
    
-    BOOST_CHECK( static_cast<bool>((j + 2) == 5) );
-    BOOST_CHECK( static_cast<bool>((3 + j2) == 5) );
+    BOOST_CHECK( (j + 2) == 5 );
+    BOOST_CHECK( (3 + j2) == 5 );
    PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
    
-    BOOST_CHECK( static_cast<bool>((j - 1) == 4) );
+    BOOST_CHECK( (j - 1) == 4 );
    PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
    
-    BOOST_CHECK( static_cast<bool>((j * 2) == 8) );
-    BOOST_CHECK( static_cast<bool>((4 * j2) == 8) );
+    BOOST_CHECK( (j * 2) == 8 );
+    BOOST_CHECK( (4 * j2) == 8 );
    PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
    
-    BOOST_CHECK( static_cast<bool>((j / 2) == 4) );
+    BOOST_CHECK( (j / 2) == 4 );
    PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
    
-    BOOST_CHECK( static_cast<bool>((j % 3) == 1) );
+    BOOST_CHECK( (j % 3) == 1 );
    PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
    
    PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
    
-    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) );
+    BOOST_CHECK( (1 | j2 | j) == 7 );
+    BOOST_CHECK( (j1 | 2 | j) == 7 );
+    BOOST_CHECK( (j1 | j2 | 4) == 7 );
    PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
    
-    BOOST_CHECK( static_cast<bool>((7 & j2) == 2) );
-    BOOST_CHECK( static_cast<bool>((j & 2) == 2) );
+    BOOST_CHECK( (7 & j2) == 2 );
+    BOOST_CHECK( (j & 2) == 2 );
    PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
    
    PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
    
-    BOOST_CHECK( static_cast<bool>((3 ^ j1) == 2) );
-    BOOST_CHECK( static_cast<bool>((j ^ 1) == 2) );
+    BOOST_CHECK( (3 ^ j1) == 2 );
+    BOOST_CHECK( (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( static_cast<bool>((j1 << 2) == 4) );
-    BOOST_CHECK( static_cast<bool>((j2 << 1) == 4) );
+    BOOST_CHECK( (j1 << 2) == 4 );
+    BOOST_CHECK( (j2 << 1) == 4 );
    PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );

-    BOOST_CHECK( static_cast<bool>((j >> 2) == 1) );
-    BOOST_CHECK( static_cast<bool>((j2 >> 1) == 1) );
+    BOOST_CHECK( (j >> 2) == 1 );
+    BOOST_CHECK( (j2 >> 1) == 1 );
    PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
    
    cout << "Performed tests on MyLong objects.\n";
@@ -785,14 +741,14 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );

-    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) );
+    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 );
    
    cout << "Performed tests on MyChar objects.\n";

@@ -808,31 +764,31 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (l = l2), (l.value() == 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) );
+    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 );
    
    cout << "Performed tests on MyShort objects.\n";
    
@@ -851,37 +807,37 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
    
-    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) );
+    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) );

    cout << "Performed tests on MyDoubleInt objects.\n";

@@ -898,42 +854,42 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
    
-    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) );
+    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) );

    cout << "Performed tests on MyLongInt objects.\n";

--- a/ref_test.cpp
+++ b/ref_test.cpp
@@ -68,54 +68,11 @@ 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;
 }
--- a/swap.html
+++ b/swap.html
@@ -14,7 +14,7 @@
      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
    </p>
     
-    <!-- Intoduction -->
+    <!-- Introduction -->
    <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>
@@ -24,10 +24,10 @@
    <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.
+      The alternative to using argument dependent lookup in this situation is to provide a template specialization of <tt>std::swap</tt> 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>.      
+      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> originally did not do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been accepted by the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.
    </p>
    
    <!-- Exception Safety -->
@@ -45,11 +45,11 @@
    </ul>
    <p>Or:</p>
    <ul>
-      <li>A function with the signature <tt>swap(T&,T&)</tt> is available via argument dependent lookup</li>
+      <li>A function with the signature <tt>swap(T&amp;,T&amp;)</tt> is available via argument dependent lookup</li>
    </ul>
    <p>Or:</p>
    <ul>
-      <li>A template specialization of std::swap exists for T</li>
+      <li>A template specialization of <tt>std::swap</tt> exists for T</li>
    </ul>
    <p>Or:</p>
    <ul>
@@ -73,18 +73,18 @@
        <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 make boost::swap less specialized than std::swap, thereby allowing the function to have the name 'swap' without introducing ambiguity
+        <em>Steven Watanabe</em> - for the idea to make <tt>boost::swap</tt> less specialized than <tt>std::swap</tt>, thereby allowing the function to have the name 'swap' without introducing ambiguity
      </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>
+    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">LWG Defect Report 809 (std::swap should be overloaded for array types)</a></p>

    <!-- Copyright info -->    
    <hr/>
-    <p>Revised: 4 August 2008</p>
+    <p>Revised: 15 November 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;.)
--- a/swap/test/Jamfile.v2
+++ b/swap/test/Jamfile.v2
@@ -29,5 +29,9 @@ test-suite utility/swap
    [ run std_vector_of_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
    [ run std_vector_of_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static            ]
    [ run no_ambiguity_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
-    [ run swap_arrays.cpp ../../../test/build//boost_test_exec_monitor/<link>static                    ]
+    [ run array_of_array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static        ]
+    [ run array_of_array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
+    [ run array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static                 ]
+    [ run array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static                   ]
+    [ run array_of_template.cpp ../../../test/build//boost_test_exec_monitor/<link>static              ]
    ;
--- a/swap/test/array_of_array_of_class.cpp
+++ b/swap/test/array_of_array_of_class.cpp
@@ -4,6 +4,8 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

+// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
@@ -33,32 +35,8 @@ namespace std
  }
 }

-// Tests swapping 1-dimensional arrays.
-void test_swapping_1D_arrays()
-{
-  const std::size_t dimension = 2;
-  const swap_test_class initial_array1[dimension] = { swap_test_class(1), swap_test_class(2) };
-  const swap_test_class initial_array2[dimension] = { swap_test_class(3), swap_test_class(4) };
-  
-  swap_test_class array1[dimension];
-  swap_test_class array2[dimension];

-  std::copy(initial_array1, initial_array1 + dimension, array1);
-  std::copy(initial_array2, initial_array2 + dimension, array2);
-  
-  swap_test_class::reset();
-  boost::swap(array1, array2);
-
-  BOOST_CHECK(std::equal(array1, array1 + dimension, initial_array2));
-  BOOST_CHECK(std::equal(array2, array2 + dimension, initial_array1));
-
-  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), dimension);
-  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
-}
-
-
-// Tests swapping 2-dimensional arrays.
-void test_swapping_2D_arrays()
+int test_main(int, char*[])
 {
  const std::size_t first_dimension = 3;
  const std::size_t second_dimension = 4;
@@ -76,7 +54,6 @@ void test_swapping_2D_arrays()
    ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
  }

-  swap_test_class::reset();
  boost::swap(array1, array2);

  for (std::size_t i = 0; i < number_of_elements; ++i)
@@ -87,14 +64,6 @@ void test_swapping_2D_arrays()

  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
-}
-
-
-int test_main(int, char*[])
-{
-  test_swapping_1D_arrays();
-  test_swapping_2D_arrays();

  return 0;
 }
-
--- a/swap/test/array_of_array_of_int.cpp
+++ b/swap/test/array_of_array_of_int.cpp
@@ -0,0 +1,42 @@
+// 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)
+
+// Tests swapping an array of arrays of integers by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+int test_main(int, char*[])
+{
+  const std::size_t first_dimension = 3;
+  const std::size_t second_dimension = 4;
+  const std::size_t number_of_elements = first_dimension * second_dimension;
+
+  int array1[first_dimension][second_dimension];
+  int array2[first_dimension][second_dimension];
+
+  int* const ptr1 = array1[0];
+  int* const ptr2 = array2[0];
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    ptr1[i] = static_cast<int>(i);
+    ptr2[i] = static_cast<int>(i + number_of_elements);
+  }
+
+  boost::swap(array1, array2);
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    BOOST_CHECK_EQUAL(ptr1[i], static_cast<int>(i + number_of_elements) );
+    BOOST_CHECK_EQUAL(ptr2[i], static_cast<int>(i) );
+  }
+  return 0;
+}
--- a/swap/test/array_of_class.cpp
+++ b/swap/test/array_of_class.cpp
@@ -0,0 +1,61 @@
+// 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)
+
+// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+
+#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"
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+//Provide swap function in both the namespace of swap_test_class
+//(which is the global namespace), and the std namespace.
+//It's common to provide a swap function for a class in both
+//namespaces. Scott Meyers recommends doing so: Effective C++,
+//Third Edition, item 25, "Consider support for a non-throwing swap".
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 2;
+  const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
+  
+  swap_test_class array1[array_size];
+  swap_test_class array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  swap_test_class::reset();
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
--- a/swap/test/array_of_int.cpp
+++ b/swap/test/array_of_int.cpp
@@ -0,0 +1,35 @@
+// 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)
+
+// Tests swapping an array of integers by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 3;
+  const int initial_array1[array_size] = { 1, 2, 3 };
+  const int initial_array2[array_size] = { 4, 5, 6 };
+  
+  int array1[array_size];
+  int array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  return 0;
+}
--- a/swap/test/array_of_template.cpp
+++ b/swap/test/array_of_template.cpp
@@ -0,0 +1,71 @@
+// 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)
+
+// Tests swapping an array of swap_test_template<int> objects by means of boost::swap.
+
+#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"
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+template <class T>
+class swap_test_template
+{
+public:
+  typedef T template_argument;
+  swap_test_class swap_test_object;
+};
+
+template <class T>
+inline bool operator==(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
+{
+  return lhs.swap_test_object == rhs.swap_test_object;
+}
+
+template <class T>
+inline bool operator!=(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+//Provide swap function in the namespace of swap_test_template
+//(which is the global namespace).  Note that it isn't allowed to put
+//an overload of this function within the std namespace.
+template <class T>
+void swap(swap_test_template<T>& left, swap_test_template<T>& right)
+{
+  left.swap_test_object.swap(right.swap_test_object);
+}
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 2;
+  const swap_test_template<int> initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_template<int> initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
+  
+  swap_test_template<int> array1[array_size];
+  swap_test_template<int> array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  swap_test_class::reset();
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -0,0 +1,38 @@
+boost_additional_test_dependencies(utility BOOST_DEPENDS test)
+
+boost_test_run(addressof_test ../addressof_test.cpp)
+boost_test_run(assert_test ../assert_test.cpp)
+boost_test_run(base_from_member_test ../base_from_member_test.cpp)
+boost_test_run(binary_search_test ../binary_search_test.cpp)
+boost_test_run(call_traits_test ../call_traits_test.cpp ARGS -u)
+boost_test_compile_fail(checked_delete_test ../checked_delete_test.cpp)
+boost_test_run(compressed_pair_test 
+  ../compressed_pair_test 
+  DEPENDS boost_test_exec_monitor)
+boost_test_run(current_function_test ../current_function_test.cpp)
+boost_test_run(iterators_test 
+  ../iterators_test.cpp 
+  DEPENDS boost_test_exec_monitor)
+boost_test_run(next_prior_test DEPENDS boost_test_exec_monitor)
+boost_test_compile_fail(noncopyable_test ../noncopyable_test.cpp)
+boost_test_run(numeric_traits_test ../numeric_traits_test.cpp)
+if (${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
+boost_test_compile_fail("operators_test_compilerbug")
+elseif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
+boost_test_run(operators_test 
+  ../operators_test.cpp
+  DEPENDS boost_test_exec_monitor)
+endif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
+boost_test_compile(ref_ct_test ../ref_ct_test.cpp)
+boost_test_run(ref_test 
+  ../ref_test.cpp
+  DEPENDS boost_test_exec_monitor)
+boost_test_compile(result_of_test)
+boost_test_run(shared_iterator_test ../shared_iterator_test.cpp)
+boost_test_run(value_init_test ../value_init_test.cpp)
+boost_test_compile_fail(value_init_test_fail1 
+  ../value_init_test_fail1.cpp)
+boost_test_compile_fail(value_init_test_fail2
+  ../value_init_test_fail2.cpp)
+boost_test_compile_fail(value_init_test_fail3
+  ../value_init_test_fail3.cpp)
--- a/test/result_of_test.cpp
+++ b/test/result_of_test.cpp
@@ -11,101 +11,35 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>

-struct int_result_type
-{
-  typedef int result_type;
-  result_type operator()(float);
-};
+struct int_result_type { typedef int result_type; };

 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_and_char_return
+struct int_result_type_and_float_result_of
 {
  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;
-  result_type operator()(float);
-};
+struct int_result_type_template { typedef int result_type; };

 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_and_char_return_template
+struct int_result_type_and_float_result_of_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 {};
@@ -126,37 +60,16 @@ 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<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<const int_result_of_template<void>(double)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::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<int_result_type_and_float_result_of_template<void>(char)>::type, int>::value));
  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)); 
@@ -168,31 +81,5 @@ 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));
-
-  typedef int (*pf_t)(int);
-  BOOST_STATIC_ASSERT((is_same<result_of<pf_t(int)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<pf_t const(int)>::type,int>::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;
 }
--- a/throw_exception.html
+++ b/throw_exception.html
@@ -1,58 +1,15 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
-	<head>
-		<title>Boost: throw_exception.hpp documentation</title>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	</head>
-	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
-				</td>
-				<td align="center">
-					<h1>throw_exception.hpp</h1>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<p>
-			The header <STRONG>&lt;boost/throw_exception.hpp&gt;</STRONG> defines the 
-			helper function <STRONG>boost::throw_exception</STRONG>. It is intended to be 
-			used in Boost libraries that need to throw exceptions, but support 
-			configurations and platforms where exceptions aren't available, as indicated by 
-			the presence of the <STRONG>BOOST_NO_EXCEPTIONS</STRONG> <A href="../config/config.htm#macro_ref">
-				configuration macro</A>.
-		</p>
-		<P>When <STRONG>BOOST_NO_EXCEPTIONS</STRONG> is not defined, <tt>boost::throw_exception(e)</tt>
-			is equivalent to <tt>throw e</tt>. Otherwise, the function is left undefined, 
-			and the user is expected to supply an appropriate definition. Callers of <tt>throw_exception</tt>
-			are allowed to assume that the function never returns; therefore, if the 
-			user-defined <tt>throw_exception</tt> returns, the behavior is undefined.</P>
-		<h3><a name="Synopsis">Synopsis</a></h3>
-		<pre>
-namespace boost
-{
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-void throw_exception(std::exception const &amp; e); // user defined
-
-#else
-
-template&lt;class E&gt; void throw_exception(E const &amp; e)
-{
-    throw e;
-}
-
-#endif
-
-}
-</pre>
-		<p><br>
-			<small>Copyright <20> 2002 by Peter Dimov. 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 <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
-	</body>
+<head>
+<meta http-equiv=refresh content="0; URL=../exception/doc/throw_exception.html">
+<title>Automatic redirection</title>
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../exception/doc/throw_exception.html">throw_exception.html</a>.&nbsp;<hr>
+<p><EFBFBD> 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 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
 </html>
--- a/utility.htm
+++ b/utility.htm
@@ -154,13 +154,11 @@ 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.</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>,
+                type. 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>. When <code>F</code>
-                does not contain <code>result_type</code>, 
+                <code>F::result_type</code>. Otherwise,
                <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
Author	SHA1	Message	Date
Beman Dawes	570b84cdc7	Release 1.37.0 [SVN r51178]	2009-02-10 13:14:42 +00:00
Emil Dotchevski	b2e6a82adb	This html was outdated; changed to forward to throw_exception.html documentation from Boost Exception [SVN r50880]	2009-01-29 19:14:05 +00:00
Troy D. Straszheim	390372294a	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Niels Dekker	ffbbf38e12	Merged new array-of-array tests of swap utility from trunk to release branch, following changeset [49954]. [SVN r50227]	2008-12-09 18:21:25 +00:00
Niels Dekker	9e73b2c6ae	Merged value_initialized::swap from trunk [48424] and [48425], according to ticket #2243 , as was agreed with Fernando Cacciola. [SVN r49967]	2008-11-27 19:37:39 +00:00
Niels Dekker	633832e872	Merged libs/utility/swap.html from trunk to release (r47094 through r49914) [SVN r49915]	2008-11-24 16:50:22 +00:00
Daniel James	862cb2a4e0	Merged revisions 49661-49662,49666,49669,49735,49756,49770,49811 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r49661 \| danieljames \| 2008-11-09 12:03:45 +0000 (Sun, 09 Nov 2008) \| 1 line Move hash detail headers out of boost/functional/detail. ........ r49662 \| danieljames \| 2008-11-09 12:11:50 +0000 (Sun, 09 Nov 2008) \| 1 line Add a forwarding header for container_fwd.hpp ........ r49666 \| danieljames \| 2008-11-09 19:12:05 +0000 (Sun, 09 Nov 2008) \| 1 line Avoid comparing default initialised iterators in position_iterator. ........ r49669 \| danieljames \| 2008-11-09 21:57:38 +0000 (Sun, 09 Nov 2008) \| 2 lines Add link to the header to the synopsis in reference documentation. Refs #2214 ........ r49735 \| danieljames \| 2008-11-14 12:51:00 +0000 (Fri, 14 Nov 2008) \| 1 line Explicitly specify the template parameters in the unordered container friend, in order to avoid some warnings. ........ r49756 \| danieljames \| 2008-11-14 16:11:16 +0000 (Fri, 14 Nov 2008) \| 1 line Use pragmas to suppress a Visual C++ warning. ........ r49770 \| danieljames \| 2008-11-15 13:07:29 +0000 (Sat, 15 Nov 2008) \| 1 line Use the new swap library. ........ r49811 \| danieljames \| 2008-11-16 23:10:00 +0000 (Sun, 16 Nov 2008) \| 1 line Fix a typo. ........ [SVN r49855]	2008-11-20 22:53:20 +00:00
Joseph Gauterin	b012f16ee5	Merged utility/swap documentation to release branch. [SVN r49763]	2008-11-15 01:15:54 +00:00
Joseph Gauterin	3d96ab26d4	Merged utility/swap tests to release branch. [SVN r49762]	2008-11-15 01:13:01 +00:00
Joseph Gauterin	8652bf51ec	Merged utility/swap to release branch. [SVN r49761]	2008-11-15 01:11:24 +00:00
Nicola Musatti	9168cb9c61	CodeGear patch. Fixes #2341 [SVN r49319]	2008-10-13 19:21:03 +00:00
Daniel James	e1991374ae	Merge quickbook workaround and fix some links. Merged revisions 48987,49230-49231 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r48987 \| danieljames \| 2008-09-28 13:21:39 +0100 (Sun, 28 Sep 2008) \| 1 line Clean up some link errors. ........ r49230 \| danieljames \| 2008-10-09 23:13:48 +0100 (Thu, 09 Oct 2008) \| 1 line position_iterator is meant to be a forward iterator, so avoid using operator+ with it. ........ r49231 \| danieljames \| 2008-10-09 23:14:14 +0100 (Thu, 09 Oct 2008) \| 4 lines Work around the problems with window newlines in position_iterator. (I'm about to fix them, but this will get quickbook working immediately). Fixes #2155 ........ [SVN r49242]	2008-10-10 09:29:21 +00:00
Emil Dotchevski	d0ee9a7c28	Boost Exception major refactoring: works with or without RTTI, vastly improved boost::throw_exception integration. [SVN r48905]	2008-09-19 20:29:26 +00:00
Matthew Calabrese	10e83b490b	Merged BOOST_BINARY utility macro. [SVN r48879]	2008-09-19 08:19:02 +00:00
Marshall Clow	4b24dba257	Replaced copyright symbols with (c) to match trunk [SVN r48842]	2008-09-18 02:54:03 +00:00
Daniel James	7a036f6f3a	Merge some small fixes from trunk. Merged revisions 46740,46742,47002,47040 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r46740 \| danieljames \| 2008-06-26 20:20:56 +0100 (Thu, 26 Jun 2008) \| 1 line Fix a character encoding error. ........ r46742 \| danieljames \| 2008-06-26 20:25:38 +0100 (Thu, 26 Jun 2008) \| 6 lines Give the asio documentation its own target. The asio documentation is built with the rest of the combined documentation but is really separate. So give it its own target so that separate parts can be built separately. ........ r47040 \| danieljames \| 2008-07-03 15:34:56 +0100 (Thu, 03 Jul 2008) \| 1 line Workaround for some template syntax not supported in old versions of Visual C++ 6.5 ........ [SVN r47078]	2008-07-04 17:04:47 +00:00
Emil Dotchevski	e632b0fb1f	Boost Exception In other libraries, watch for compile error referring to throw_exception_assert_compatibility in boost::throw_exception. Resolve by throwing an exception that derives from std::exception. This is not a new requirement but it is being enforced now. [SVN r46818]	2008-06-28 18:29:40 +00:00
Beman Dawes	17bee9d43f	With his kind permission, change Jaakko "Järvi" to "Jarvi" [SVN r46809]	2008-06-28 13:57:20 +00:00
Anthony Williams	492a8ad213	Merge of new boost.thread code along with required changes from boost.bind [SVN r46474]	2008-06-18 13:01:08 +00:00
Niels Dekker	8827b8ed8b	Merged value_init doc + test from trunk, including doc and test for boost::initialized_value, that was added with changeset [46464] [SVN r46465]	2008-06-17 22:17:14 +00:00
Niels Dekker	8849fbc52d	Merged value_init.hpp from trunk, including new boost::initialized_value object. (Was discussed beforehand with Fernando Cacciola.) [SVN r46464]	2008-06-17 22:14:09 +00:00
Daniel James	50bc75a802	Add minor documentation fixes to the release branch. (I left out the changes to the hash library). Merged via svnmerge from https://svn.boost.org/svn/boost/trunk ................ r44807 \| danieljames \| 2008-04-27 08:39:49 +0100 (Sun, 27 Apr 2008) \| 78 lines Merge in documentation fixes. Apart from the change to optional's documenation Jamfile, which I included by mistake. I wrote about this at: http://lists.boost.org/Archives/boost/2008/04/136405.php Merged revisions 44585-44806 via svnmerge from https://svn.boost.org/svn/boost/branches/doc ........ r44585 \| danieljames \| 2008-04-19 16:25:27 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix broken link to vacpp in bjam docs. ........ r44586 \| danieljames \| 2008-04-19 16:27:36 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix broken link to bcpp in bjam docs. ........ r44587 \| danieljames \| 2008-04-19 16:33:58 +0100 (Sat, 19 Apr 2008) \| 2 lines DateTime documentation - Fix a link to the serialization library. ........ r44588 \| danieljames \| 2008-04-19 16:35:36 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in interprocess & intrusive. ........ r44589 \| danieljames \| 2008-04-19 16:37:39 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in the python docs. ........ r44590 \| danieljames \| 2008-04-19 16:38:29 +0100 (Sat, 19 Apr 2008) \| 2 lines Work around a quickbook bug which is affecting the python docs. ........ r44591 \| danieljames \| 2008-04-19 16:39:34 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix a broken link in the numeric conversion docs. ........ r44592 \| danieljames \| 2008-04-19 16:40:45 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in the optional docs. ........ r44593 \| danieljames \| 2008-04-19 16:42:09 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix link to the hash documentation from bimap. ........ r44599 \| danieljames \| 2008-04-19 18:07:33 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix a typo in the format library. ........ r44600 \| danieljames \| 2008-04-19 19:20:59 +0100 (Sat, 19 Apr 2008) \| 1 line Initialise svnmerge. ........ r44641 \| danieljames \| 2008-04-20 18:59:47 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix the lincense url in shared container iterator documentation. ........ r44642 \| danieljames \| 2008-04-20 19:00:00 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix image link in the mpi documentation. ........ r44643 \| danieljames \| 2008-04-20 19:00:11 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix a typo in the spirit docs. ........ r44644 \| danieljames \| 2008-04-20 19:00:23 +0100 (Sun, 20 Apr 2008) \| 2 lines Escape the slash so that quickbook doesn't think it the start of an italic section, and mess up the link. Refs #1844 ........ r44647 \| danieljames \| 2008-04-20 19:39:47 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix another typo in spirit docs. ........ ................ r45232 \| danieljames \| 2008-05-08 22:50:19 +0100 (Thu, 08 May 2008) \| 1 line Fix some invalid xml by replacing ampersands with character entities. ................ r45576 \| danieljames \| 2008-05-20 16:39:25 +0100 (Tue, 20 May 2008) \| 20 lines Merge some small documentation fixes from the doc branch, and mark some previously merged changes as merged. Merged revisions 44811,45129,45142,45154,45281-45282,45365 via svnmerge from https://svn.boost.org/svn/boost/branches/doc ........ r45129 \| danieljames \| 2008-05-05 12:36:50 +0100 (Mon, 05 May 2008) \| 2 lines Update navbar links in boostbook. ........ r45282 \| danieljames \| 2008-05-11 14:15:31 +0100 (Sun, 11 May 2008) \| 2 lines Group functions in the hash header - requires Frank's free-function-group fix. (not included in release branch). ........ r45365 \| danieljames \| 2008-05-14 21:39:00 +0100 (Wed, 14 May 2008) \| 2 lines Add boost.root to standalone hash documentation. (not included in release branch). ........ ................ [SVN r45622]	2008-05-21 20:57:05 +00:00
John Maddock	9b52e49fda	Merge inspection failure fixes from Trunk. [SVN r43634]	2008-03-15 18:45:28 +00:00
Daniel James	ab479794f3	Merged revisions 43206,43208-43213 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43206 \| danieljames \| 2008-02-10 09:55:03 +0000 (Sun, 10 Feb 2008) \| 1 line Fix some broken links. ........ r43209 \| danieljames \| 2008-02-10 14:56:22 +0000 (Sun, 10 Feb 2008) \| 1 line Link to people pages on the website, as they've been removed from the download. ........ r43210 \| danieljames \| 2008-02-10 15:02:17 +0000 (Sun, 10 Feb 2008) \| 1 line Point links to the pages that used to be in 'more' to the site. ........ r43212 \| danieljames \| 2008-02-10 16:10:16 +0000 (Sun, 10 Feb 2008) \| 1 line Fix links on the home page as well. ........ r43213 \| danieljames \| 2008-02-10 16:21:22 +0000 (Sun, 10 Feb 2008) \| 1 line Generated documentation which is no longer generated. ........ [SVN r43214]	2008-02-10 16:39:38 +00:00
Niels Dekker	97b8966337	value_init doc + test: Merged from trunk changeset [42798] to release. [SVN r42799]	2008-01-15 19:55:28 +00:00
Niels Dekker	88099a882f	Merged value_init.hpp from trunk [42277] to release branch, thereby resolving ticket #1459 and #1491 . Fernando Cacciola (owner of value_init) encouraged me to do the commit. [SVN r42501]	2008-01-05 22:38:50 +00:00
Beman Dawes	d5554eb6d7	Pick up missing smart_ptr, utility, and type_traits files from full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41386]	2007-11-25 22:34:55 +00:00
Beman Dawes	13bdfb8bbd	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	74462349c2	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	6aa648d315	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	9ff18c2c96	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Daniel Frey	d5ea07c737	Merged changes for ticket #979 from HEAD [SVN r37920]	2007-06-06 20:57:40 +00:00
Fernando Cacciola	aa0096bf42	Testsuite for none_t added. [SVN r37421]	2007-04-12 14:32:38 +00:00
Daniel James	005c2f3cc8	Fix a couple of links. [SVN r36656]	2007-01-07 22:58:41 +00:00
Andreas Huber	09f7aab52d	Merged L & C issue fixes & HTML conversions from trunk to branch. [SVN r36281]	2006-12-05 22:33:21 +00:00
Peter Dimov	30a40f9f76	Linked to current_function.html [SVN r36268]	2006-12-04 20:31:38 +00:00
Vladimir Prus	d9f8bae673	Merge from HEAD. Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35990]	2006-11-10 19:59:52 +00:00
Peter Dimov	3c7b409460	License/copyright edits [SVN r35958]	2006-11-09 20:34:33 +00:00
Beman Dawes	ee3551e8dc	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	95da2e90de	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
John Maddock	6dd93ab916	Removed unneeded semicolon. [SVN r35636]	2006-10-16 18:01:40 +00:00
Hartmut Kaiser	505d419a1b	Resolved an ambiguity. [SVN r35039]	2006-09-08 00:16:31 +00:00
Gennaro Prota	d968b5f5b9	boost guidelines (mainly from inspect tool: tabs, license reference text, etc.); more to do... [SVN r34753]	2006-07-27 11:48:49 +00:00
nobody	d809d4e832	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00
				`@@ -0,0 +1 @@`
				`boost_module(utility DEPENDS iterator exception detail )`