Branch for development of boost.system related changes

[SVN r40931]
Copyright and/or License cleanup
2007-11-08 14:20:16 +00:00 · 2007-11-07 16:08:09 +00:00 · 2007-11-04 12:01:16 +00:00 · 2007-11-03 22:47:17 +00:00 · 2007-11-03 20:55:22 +00:00 · 2007-10-16 17:06:39 +00:00
24 changed files with 654 additions and 285 deletions
--- a/OptionalPointee.html
+++ b/OptionalPointee.html
@ -145,14 +145,20 @@ objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp"
 so direct usage of relational operators with the implied aliasing of shallow semantics
 -as with pointers- should not be used with generic code written for this concept.</p>

+<h3>Acknowledgements</h3>
+<p>Based on the original concept developed by Augustus Saunders.
+
 <br>
+</p>
 <HR>
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2003</TD><TD>
-<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>,
-based on the original concept developed by Augustus Saunders.
+<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>
 </TD></TR></TABLE>

+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 </BODY>
 </HTML>
--- a/assert.html
+++ b/assert.html
@ -47,9 +47,15 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT</STRONG>
 			will be redefined each time as specified above.</P>
+		<p><STRONG>&lt;boost/assert.hpp&gt;</STRONG> also defines the macro <STRONG>BOOST_VERIFY</STRONG>. 
+			It has exactly the same behavior as <STRONG>BOOST_ASSERT</STRONG>, except that 
+			the expression that is passed to <STRONG>BOOST_VERIFY</STRONG> is always 
+			evaluated. This is useful when the asserted expression has desirable side 
+			effects; it can also help suppress warnings about unused variables when the 
+			only use of the variable is inside an assertion.</p>
 		<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>
+			<small>Copyright <20> 2002, 2007 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>
 </html>
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -3,7 +3,7 @@
      <title>Header </title>
      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
      <meta name="Template" content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-      <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+      <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
      <boostcompressed_pair.hpp>
   </head>
   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
@ -59,17 +59,18 @@ public:
         empty type, then assigning to that member will produce memory corruption, 
         unless the empty type has a "do nothing" assignment operator defined. This is 
         due to a bug in the way VC6 generates implicit assignment operators.</p>
-      <hr>
-      <p>Revised 08 May 2001</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 "as is" without express or implied 
-         warranty, and with no claim as to its suitability for any purpose.</p>
+      <h3>Acknowledgements</h3>
      <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>&nbsp;</p>
+      <hr>
+      <p>Revised
+      <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->07 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40338" --></p>
+      <p><EFBFBD> Copyright Beman Dawes, 2000.</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
   </body>
-</html>
+</html>
--- a/in_place_factories.html
+++ b/in_place_factories.html
@ -3,9 +3,8 @@
 <HTML>

 <HEAD>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-<LINK REL="stylesheet" TYPE="text/css" HREF="../../boost.css">
-<TITLE>Header </TITLE>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
+<TITLE>In_place_factory Documentation</TITLE>
 </HEAD>

 <BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
@ -77,7 +76,7 @@ object is likely to be temporary and serve no purpose besides being the source</
 </pre>
 <p>A solution to this problem is to support direct construction of the contained
 object right in the container's storage.<br>
-In this shceme, the user supplies the arguments for the X constructor
+In this scheme, the user supplies the arguments for the X constructor
 directly to the container:</p>
 <pre>struct C
 {
@ -138,7 +137,7 @@ The following simplified example shows the basic idea. A complete example follow

 void foo()
 {
-  C c( in_place(123,"hello" ) ;
+  C c( in_place(123,"hello") ) ;
 }
 </pre>

--- a/include/boost/assert.hpp
+++ b/include/boost/assert.hpp
@ -2,6 +2,7 @@
 //  boost/assert.hpp - BOOST_ASSERT(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -35,3 +36,15 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
+
+#undef BOOST_VERIFY
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
+
+# define BOOST_VERIFY(expr) ((void)(expr))
+
+#else
+
+# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+
+#endif
--- a/include/boost/current_function.hpp
+++ b/include/boost/current_function.hpp
@ -32,6 +32,10 @@ inline void current_function_helper()

 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__

+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
 #elif defined(__FUNCSIG__)

 # define BOOST_CURRENT_FUNCTION __FUNCSIG__
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@ -8,6 +8,8 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

 //  Revision History
+//  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
 //            correct named return value optimization (NRVO) to produce optimal
 //            code.  (Daniel Frey)
@ -90,15 +92,15 @@
 namespace boost {
 namespace detail {

+template <typename T> class empty_base {
+
 // Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
-class empty_base {
  bool dummy; 
-};
-#else
-class empty_base {};
 #endif

+};
+
 } // namespace detail
 } // namespace boost

@ -119,7 +121,7 @@ namespace boost
 //  Note that friend functions defined in a class are implicitly inline.
 //  See the C++ std, 11.4 [class.friend] paragraph 5

-template <class T, class U, class B = ::boost::detail::empty_base>
+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); }
@ -130,7 +132,7 @@ struct less_than_comparable2 : B
     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+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; }
@ -138,7 +140,7 @@ struct less_than_comparable1 : B
     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
 };

-template <class T, class U, class B = ::boost::detail::empty_base>
+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; }
@ -146,7 +148,7 @@ struct equality_comparable2 : B
     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+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); }
@ -165,7 +167,7 @@ struct equality_comparable1 : B
 // implementation available.

 #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const U& rhs )                          \
@ -174,33 +176,33 @@ struct NAME##2 : B                                                            \
    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const T& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };

-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )           \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct NAME##2 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const U& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                               \
-{                                                                   \
-  friend T operator OP( const U& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class B = ::boost::detail::empty_base>           \
-struct NAME##1 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const U& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
+{                                                                       \
+  friend T operator OP( const U& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
 };

 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@ -210,35 +212,35 @@ struct NAME##1 : B                                                  \
 // BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
 // optimization opportunities to the compiler :)

-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
-  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; }       \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
 };

 #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
 struct NAME##2 : B                                                      \
 {                                                                       \
  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
 };                                                                      \
                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
 struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
 {                                                                       \
  friend T operator OP( const U& lhs, const T& rhs )                    \
    { return T( lhs ) OP##= rhs; }                                      \
 };                                                                      \
                                                                        \
-template <class T, class B = ::boost::detail::empty_base>               \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
 struct NAME##1 : B                                                      \
 {                                                                       \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
@ -261,7 +263,7 @@ BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )

 //  incrementable and decrementable contributed by Jeremy Siek

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct incrementable : B
 {
  friend T operator++(T& x, int)
@ -274,7 +276,7 @@ private: // The use of this typedef works around a Borland bug
  typedef T incrementable_type;
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct decrementable : B
 {
  friend T operator--(T& x, int)
@ -289,7 +291,7 @@ private: // The use of this typedef works around a Borland bug

 //  Iterator operator classes (contributed by Jeremy Siek) ------------------//

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct dereferenceable : B
 {
  P operator->() const
@ -298,7 +300,7 @@ struct dereferenceable : B
  }
 };

-template <class T, class I, class R, class B = ::boost::detail::empty_base>
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
 struct indexable : B
 {
  R operator[](I n) const
@ -313,14 +315,14 @@ struct indexable : B
 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)

 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const U& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const T& rhs )                          \
@ -330,13 +332,13 @@ struct NAME##1 : B                                                            \
 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)

 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
@ -349,7 +351,7 @@ BOOST_BINARY_OPERATOR( right_shiftable, >> )

 #undef BOOST_BINARY_OPERATOR

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct equivalent2 : B
 {
  friend bool operator==(const T& x, const U& y)
@ -358,7 +360,7 @@ struct equivalent2 : B
  }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct equivalent1 : B
 {
  friend bool operator==(const T&x, const T&y)
@ -367,7 +369,7 @@ struct equivalent1 : B
  }
 };

-template <class T, class U, class B = ::boost::detail::empty_base>
+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)
@ -384,7 +386,7 @@ struct partially_ordered2 : B
    { return (y < x) || (y == x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct partially_ordered1 : B
 {
  friend bool operator>(const T& x, const T& y)
@ -397,161 +399,161 @@ struct partially_ordered1 : B

 //  Combined operator classes (contributed by Daryle Walker) ----------------//

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
@ -560,43 +562,43 @@ struct euclidian_ring_operators2
    , modable2_left<T, U, B
      > > > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};
      
-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct output_iteratable
    : incrementable<T, B
      > {};

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
@ -606,7 +608,7 @@ struct bidirectional_iteratable
 //  which is an indirect base class of bidirectional_iterable,
 //  random_access_iteratable must not be derived from totally_ordered1
 //  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
 struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
@ -650,20 +652,20 @@ struct random_access_iteratable

     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
     // from working, we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
-     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
+#    define BOOST_IMPORT_TEMPLATE4(template_name)                                             \
+     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, V, W, B> {};

-#    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
-     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
+#    define BOOST_IMPORT_TEMPLATE3(template_name)                                    \
+     template <class T, class U, class V, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, V, B> {};

-#    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
-     template <class T, class U, class B = ::boost::detail::empty_base>        \
+#    define BOOST_IMPORT_TEMPLATE2(template_name)                           \
+     template <class T, class U, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, B> {};

-#    define BOOST_IMPORT_TEMPLATE1(template_name)                              \
-     template <class T, class B = ::boost::detail::empty_base>                 \
+#    define BOOST_IMPORT_TEMPLATE1(template_name)                  \
+     template <class T, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, B> {};

 #  endif // BOOST_NO_USING_TEMPLATE
@ -752,7 +754,7 @@ template<class T> struct is_chained_base {
 # define BOOST_OPERATOR_TEMPLATE(template_name)                    \
 template <class T                                                  \
         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base                    \
+         ,class B = ::boost::detail::empty_base<T>                 \
         ,class O = typename is_chained_base<U>::value             \
         >                                                         \
 struct template_name : template_name##2<T, U, B> {};               \
@ -788,7 +790,7 @@ BOOST_OPERATOR_TEMPLATE1(template_name##1)
   // In this case we can only assume that template_name<> is equivalent to the
   // more commonly needed template_name1<> form.
 #  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
-   template <class T, class B = ::boost::detail::empty_base>       \
+   template <class T, class B = ::boost::detail::empty_base<T> >   \
   struct template_name : template_name##1<T, B> {};

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
--- a/include/boost/utility/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,25 +10,27 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP

+#include <new>
+#include <cstddef>
 #include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/punctuation/paren.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/punctuation/paren.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>

 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG(z,n,_)  BOOST_PP_CAT(m_a,n)

 #define BOOST_MAX_INPLACE_FACTORY_ARITY 10

-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP

 #endif

--- a/include/boost/utility/detail/in_place_factory_suffix.hpp
+++ b/include/boost/utility/detail/in_place_factory_suffix.hpp
@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,15 +10,14 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP

 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG
 #undef BOOST_MAX_INPLACE_FACTORY_ARITY

-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP

 #endif

--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@ -21,66 +21,69 @@
 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)>
-    : detail::result_of<F, F(BOOST_RESULT_OF_ARGS)> {};
+    : boost::detail::result_of_impl<F, F(BOOST_RESULT_OF_ARGS), (boost::detail::has_result_type<F>::value)> {};
 #endif

+#undef BOOST_RESULT_OF_ARGS
+
+#if BOOST_PP_ITERATION() >= 1 
+
 namespace detail {

 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (*)(BOOST_RESULT_OF_ARGS), FArgs>
+struct result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (&)(BOOST_RESULT_OF_ARGS), FArgs>
+struct result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

-#undef BOOST_RESULT_OF_ARGS
-
-#if BOOST_PP_ITERATION() > 1 && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     volatile,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const volatile,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };
 #endif

 }
+#endif
--- a/include/boost/utility/in_place_factory.hpp
+++ b/include/boost/utility/in_place_factory.hpp
@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,50 +10,79 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-#ifndef BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
+#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING

 #include <boost/utility/detail/in_place_factory_prefix.hpp>

-#include <boost/type.hpp>
-
 namespace boost {

 class in_place_factory_base {} ;

-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS(z,n,_) \
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) : public in_place_factory_base \
-{ \
-public: \
-\
-  BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  template<class T> \
-  void apply ( void* address BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
+#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define  BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
+#include BOOST_PP_ITERATE()

 } // namespace boost

 #include <boost/utility/detail/in_place_factory_suffix.hpp>

+#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#else
+#define N BOOST_PP_ITERATION()
+
+#if N
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+#endif
+class BOOST_PP_CAT(in_place_factory,N)
+  : 
+  public in_place_factory_base
+{
+public:
+
+  explicit BOOST_PP_CAT(in_place_factory,N)
+      ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
+#if N > 0
+    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+  {}
+
+  template<class T>
+  void* apply(void* address
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+  {
+    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+  }
+
+  template<class T>
+  void* apply(void* address, std::size_t n
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+  {
+    for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
+        !! --n;)
+      this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
+    return address; 
+  }
+
+  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+#if N > 0
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+  return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+      ( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+#else
+inline in_place_factory0 in_place()
+{
+  return in_place_factory0();
+}
+#endif
+
+#undef N
+#endif
 #endif

--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@ -15,6 +15,8 @@
 #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>

 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10
@ -29,28 +31,48 @@ namespace detail {

 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)

-template<typename F, typename FArgs, bool HasResultType> struct get_result_of;
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, true>
-{
-  typedef typename F::result_type type;
-};
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, false>
-{
-  typedef typename F::template result<FArgs>::type type;
-};
+template<typename F, typename FArgs, bool HasResultType> struct result_of_impl;

 template<typename F>
-struct get_result_of<F, F(void), false>
+struct result_of_void_impl
 {
  typedef void type;
 };

+template<typename R>
+struct result_of_void_impl<R (*)(void)>
+{
+  typedef R type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (&)(void)>
+{
+  typedef R type;
+};
+
 template<typename F, typename FArgs>
-struct result_of : get_result_of<F, FArgs, (has_result_type<F>::value)> {};
+struct result_of_impl<F, FArgs, true>
+{
+  typedef typename F::result_type type;
+};
+
+template<typename FArgs>
+struct is_function_with_no_args : mpl::false_ {};
+
+template<typename F>
+struct is_function_with_no_args<F(void)> : mpl::true_ {};
+
+template<typename F, typename FArgs>
+struct result_of_nested_result : F::template result<FArgs>
+{};
+
+template<typename F, typename FArgs>
+struct result_of_impl<F, FArgs, false>
+  : mpl::if_<is_function_with_no_args<FArgs>,
+	     result_of_void_impl<F>,
+	     result_of_nested_result<F, FArgs> >::type
+{};

 } // end namespace detail

--- a/include/boost/utility/typed_in_place_factory.hpp
+++ b/include/boost/utility/typed_in_place_factory.hpp
@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,8 +10,8 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
+#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING

 #include <boost/utility/detail/in_place_factory_prefix.hpp>

@ -18,40 +19,59 @@ namespace boost {

 class typed_in_place_factory_base {} ;

-#define BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS(z,n,_) \
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) : public typed_in_place_factory_base \
-{ \
-public: \
-\
-  typedef T value_type ; \
-\
-  BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  void apply ( void* address ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T , BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T, BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
+#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define  BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
+#include BOOST_PP_ITERATE()

 } // namespace boost

 #include <boost/utility/detail/in_place_factory_suffix.hpp>

+#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#else 
+#define N BOOST_PP_ITERATION()
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
+class BOOST_PP_CAT(typed_in_place_factory,N) 
+  : 
+  public typed_in_place_factory_base
+{
+public:
+
+  typedef T value_type;
+
+  explicit BOOST_PP_CAT(typed_in_place_factory,N) 
+      ( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+#if N > 0
+    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+  {}
+
+  void* apply (void* address) const
+  {
+    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+  }
+
+  void* apply (void* address, std::size_t n) const
+  {
+    for(void* next = address = this->apply(address); !! --n;)
+      this->apply(next = static_cast<char *>(next) + sizeof(T));
+    return address; 
+  }
+
+  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
+inline BOOST_PP_CAT(typed_in_place_factory,N)<
+    T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+  return BOOST_PP_CAT(typed_in_place_factory,N)< 
+      T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+
+#undef N
+#endif
 #endif

--- a/include/boost/utility/value_init.hpp
+++ b/include/boost/utility/value_init.hpp
@ -1,16 +1,110 @@
-// Copyright 2002, Fernando Luis Cacciola Carballal.
+// (C) Copyright 2002-2007, Fernando Luis Cacciola Carballal.
 //
 // 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)
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
+// 07 Set 2007 (Worked around MSVC++ bug) Fernando Cacciola, Niels Dekker
 //
 #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP

-#include "boost/detail/select_type.hpp"
-#include "boost/type_traits/cv_traits.hpp"
+#include <boost/detail/select_type.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
+// Microsoft Visual C++ does not correctly support value initialization, as reported by
+// Pavel Kuznetsov (MetaCommunications Engineering), 7/28/2005, Feedback ID 100744,
+// Feedback Title: Value-initialization in new-expression
+// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
+// The report was closed at 11/14/2006, and its status was set to "Closed (Won't Fix)".
+// Luckily, even in the presence of this compiler bug, boost::value_initialized will still
+// do its job correctly, when using the following workaround:
+#define BOOST_UTILITY_VALUE_INIT_WORKAROUND
+#endif
+
+#ifdef BOOST_UTILITY_VALUE_INIT_WORKAROUND
+#include <boost/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <cstring>
+#include <new>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#if _MSC_VER >= 1310
+// When using MSVC 7.1 or higher, placement new, "new (&x) T()", may trigger warning C4345:
+// "behavior change: an object of POD type constructed with an initializer of the form ()
+// will be default-initialized".  There is no need to worry about this, though.
+#pragma warning(disable: 4345)
+#endif
+#endif
+
+namespace boost {
+
+namespace vinit_detail {
+
+template<class T>
+class const_T_base
+{
+  protected :
+
+    const_T_base()
+    {
+      std::memset(&x, 0, sizeof(x));
+      new (&x) T();
+    }
+
+    ~const_T_base()
+    {
+      void const * ptr = &x;
+      static_cast<T*>(ptr)->T::~T();
+    }
+
+    T & get() const
+    {
+      void const * ptr = &x;
+      return *static_cast<T*>(ptr);
+    }
+
+  private :
+    typename ::boost::aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type x;
+} ;
+
+template<class T>
+class non_const_T_base
+{
+  protected :
+
+    non_const_T_base()
+    {
+      std::memset(&x, 0, sizeof(x));
+      new (&x) T();
+    }
+
+    ~non_const_T_base()
+    {
+      void * ptr = &x;
+      static_cast<T*>(ptr)->T::~T();
+    }
+
+    T & get() const
+    { 
+      void * ptr = &x;
+      return *static_cast<T*>(ptr);
+    }
+
+  private :
+    mutable typename ::boost::aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type x;
+} ;
+
+#ifdef BOOST_MSVC
+// Restores the state of warning C4345.
+#pragma warning(pop)
+#endif
+
+#else

 namespace boost {

@ -22,25 +116,34 @@ class const_T_base
  protected :

   const_T_base() : x() {}
+   T & get() const { return x; }

+  private :
   T x ;
 } ;

 template<class T>
-struct non_const_T_base
+class non_const_T_base
 {
  protected :

   non_const_T_base() : x() {}
+   T & get() const { return x; }

+  private :
   mutable T x ;
 } ;

+#endif
+
 template<class T>
 struct select_base
 {
-  typedef typename
-    boost::detail::if_true< ::boost::is_const<T>::value >
+  typedef
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  typename
+#endif 
+    ::boost::detail::if_true< ::boost::is_const<T>::value >
      ::template then< const_T_base<T>, non_const_T_base<T> >::type type ;
 } ;

@ -53,9 +156,9 @@ class value_initialized : private vinit_detail::select_base<T>::type

    value_initialized() {}

-    operator T&() const { return this->x ; }
+    operator T&() const { return this->get(); }

-    T& data() const { return this->x ; }
+    T& data() const { return this->get(); }

 } ;

--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -1,8 +1,7 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
+# Copyright David Abrahams 2003.
+
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt

 # For more information, see http://www.boost.org/

@ -33,5 +32,6 @@ test-suite utility
        [ compile-fail ../value_init_test_fail1.cpp ]
        [ compile-fail ../value_init_test_fail2.cpp ]
        [ compile-fail ../value_init_test_fail3.cpp ]
-        [ run none_test.cpp ]
+        [ run ../verify_test.cpp ]
    ;
+
--- a/test/none_test.cpp
+++ b/test/none_test.cpp
@ -1,22 +0,0 @@
-// Copyright 2007 Fernando Luis Cacciola Carballal.  Use, modification, and distribution
-// are subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt.)
-
-// See http://www.boost.org/libs/utility for documentation.
-
-// Boost test program for noost::none_t and boost::none
-
-// Test strategy contributed by Richard Smith
-
-#include <boost/optional/optional.hpp> // Test none.hpp is included with <optional.hpp>
-
-// Left undefined to cause a linker error if this overload is incorrectly selected.
-void verify_no_implicit_conversion_to_int ( int i ) ;
-
-void verify_no_implicit_conversion_to_int ( boost::optional<int> const& ) {}
-
-int main() 
-{
-  verify_no_implicit_conversion_to_int( boost::none );
-}
--- a/test/result_of_test.cpp
+++ b/test/result_of_test.cpp
@ -24,6 +24,24 @@ struct int_result_type_and_float_result_of
  template<typename F> struct result { typedef float type; };
 };

+template<typename T>
+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; };
+};
+
+template<typename T>
+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; };
+};
+
 struct X {};

 int main()
@ -32,10 +50,13 @@ int main()

  typedef int (*func_ptr)(float, double);
  typedef int (&func_ref)(float, double);
+  typedef int (*func_ptr_0)();
+  typedef int (&func_ref_0)();
  typedef int (X::*mem_func_ptr)(float);
  typedef int (X::*mem_func_ptr_c)(float) const;
  typedef int (X::*mem_func_ptr_v)(float) volatile;
  typedef int (X::*mem_func_ptr_cv)(float) const volatile;
+  typedef int (X::*mem_func_ptr_0)();

  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));
@ -43,11 +64,22 @@ int main()
  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));
+  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));
  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)); 
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_0()>::type, int>::value)); 
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
+  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));
+
  return 0;
 }
--- a/utility.htm
+++ b/utility.htm
@ -163,9 +163,9 @@ void f() {
                <code><em>N</em> &gt; 0</code> or <code>void</code>
                when <code><em>N</em> = 0</code>. For additional
                information about <code>result_of</code>, see the
-                current draft of the C++ Library TR, <a
-                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2004/n1647.pdf">N1647</a>,
-                or the <code>result_of</code> <a
+                C++ Library Technical Report, <a
+                href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">N1836</a>,
+                or, for motivation and design rationale, the <code>result_of</code> <a
                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>

                <p>Class template <code>result_of</code> resides in
@ -183,12 +183,12 @@ void f() {
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>
 		<hr>
 		<p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->02 May, 2004<!--webbot bot="Timestamp" endspan i-checksum="38582"
+-->07 November, 2007<!--webbot bot="Timestamp" endspan i-checksum="39369"
 -->
 		</p>
-		<p>&copy; Copyright boost.org 1999-2003. 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>&copy; Copyright Beman Dawes 1999-2003.</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 	</body>
-</html>
+</html>
--- a/value_init.htm
+++ b/value_init.htm
@ -197,23 +197,23 @@ the wrapped object is always performed with the <code>get()</code> idiom:</p>
     value_initialized was developed by Fernando Cacciola, with help and
 suggestions from David Abrahams and Darin Adler.<br>
 Special thanks to Bj<42>rn Karlsson who carefully edited and completed this documentation.
-<pre>&nbsp;</pre>
-                    
-<hr>          
-<p>Revised 19 September 2002</p>
-                   
-<p>&copy; Copyright boost.org 2002. Permission to copy, use, modify, sell 
-and distribute this document is granted provided this copyright notice  appears 
-in all copies. This document is provided "as is" without express or implied 
-warranty, and with no claim as to its suitability for any purpose.</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>, and the boost discussion list
 at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.
     </p>
+                    
+<hr>          
+<p>Revised 19 September 2002</p>
+                   
+<p>&copy; Copyright Fernando Cacciola, 2002.</p>
+                   
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 <br>
 <br>
    
 </body>
-</html>
+</html>
--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -60,6 +60,20 @@ struct NonPOD : NonPODBase
  std::string id ;
 } ;

+//
+// Sample aggregate POD struct type
+//
+struct AggregatePODStruct
+{
+  float f;
+  char  c;
+  int   i;
+};
+
+bool operator == ( AggregatePODStruct const& lhs, AggregatePODStruct const& rhs )
+{ return lhs.f == rhs.f && lhs.c == rhs.c && lhs.i == rhs.i ; }
+
+
 template<class T>
 void test ( T const& y, T const& z )
 {
@ -95,6 +109,13 @@ int test_main(int, char **)
  test( POD(0,0,0.0), POD('a',1234,56.78) ) ;
  test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ;

+  NonPOD NonPOD_object( std::string("NonPOD_object") );
+  test<NonPOD *>( 0, &NonPOD_object ) ;
+
+  AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
+  AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
+  test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct);
+
  return 0;
 }

--- a/value_init_test_fail1.cpp
+++ b/value_init_test_fail1.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/value_init_test_fail2.cpp
+++ b/value_init_test_fail2.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/value_init_test_fail3.cpp
+++ b/value_init_test_fail3.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/verify_test.cpp
+++ b/verify_test.cpp
@ -0,0 +1,126 @@
+//
+//  verify_test.cpp - a test for BOOST_VERIFY
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/assert.hpp>
+
+int f( int & x )
+{
+    return ++x;
+}
+
+void test_default()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+}
+
+#define BOOST_DISABLE_ASSERTS
+#include <boost/assert.hpp>
+
+void test_disabled()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+
+    BOOST_VERIFY( 0 );
+    BOOST_VERIFY( !x );
+    BOOST_VERIFY( x == 0 );
+    BOOST_VERIFY( !++x );
+    BOOST_VERIFY( !f(x) );
+
+    BOOST_TEST( x == 5 );
+
+    void * p = 0;
+    BOOST_VERIFY( p );
+}
+
+#undef BOOST_DISABLE_ASSERTS
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <cstdio>
+
+int handler_invoked = 0;
+
+void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
+    ++handler_invoked;
+}
+
+struct X
+{
+    static bool f()
+    {
+        BOOST_VERIFY( 0 );
+        return false;
+    }
+};
+
+void test_handler()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+
+    BOOST_VERIFY( 0 );
+    BOOST_VERIFY( !x );
+    BOOST_VERIFY( x == 0 );
+    BOOST_VERIFY( !++x );
+    BOOST_VERIFY( !f(x) );
+
+    BOOST_TEST( x == 5 );
+
+    void * p = 0;
+    BOOST_VERIFY( p );
+
+    BOOST_VERIFY( X::f() );
+
+    BOOST_TEST( handler_invoked == 8 );
+}
+
+#undef BOOST_ENABLE_ASSERT_HANDLER
+
+int main()
+{
+    test_default();
+    test_disabled();
+    test_handler();
+
+    return boost::report_errors();
+}
Author	SHA1	Message	Date
Beman Dawes	a9a8e3cba1	Branch for development of boost.system related changes [SVN r40931]	2007-11-08 14:20:16 +00:00
Beman Dawes	b3a971e7e9	Copyright and/or License cleanup [SVN r40890]	2007-11-07 16:08:09 +00:00
John Maddock	7ddb559887	Fix path to test case. [SVN r40736]	2007-11-04 12:01:16 +00:00
Peter Dimov	ea8c99b1d5	Added a sentence with a brief explanation of the intended uses of BOOST_VERIFY. [SVN r40731]	2007-11-03 22:47:17 +00:00
Peter Dimov	56b0846099	BOOST_VERIFY added. [SVN r40728]	2007-11-03 20:55:22 +00:00
Niels Dekker	42e0001370	Added value_initialized<T> test, having T as aggregate POD struct. In the past, this would have triggered MSVC warning C4345; this warning is now disabled within value_init.hpp, changeset [40088] [SVN r40089]	2007-10-16 17:06:39 +00:00
Niels Dekker	cd8f85afee	Disabled MSVC warning C4345, in response to Gennadiy Rozental, Boost Developer mailing list, "[utility] value_init warning", October 14, 2007. Push'n'pop reminder from Paul A Bristow taken into account. [SVN r40088]	2007-10-16 17:00:28 +00:00
Markus Schöpflin	bddd52c4b9	Fixed bug preventing compilation on Tru64/CXX. [SVN r39918]	2007-10-11 07:36:41 +00:00
Niels Dekker	8f03aeac4e	Added unit test to make sure that Visual C++ 7.1 ICE reported by Ralf W. Grosse-Kunstleve (Boost Developers mailing list, subject "utility/value_init.hpp: VC 7.1 ICE & workaround") will not occur anymore. [SVN r39309]	2007-09-16 09:48:28 +00:00
Niels Dekker	3bb2568fad	Visual C++ 7.1 ICE workaround by Ralf W. Grosse-Kunstleve added to ~const_T_base() as well. See also Boost Developers mailing list, subject "utility/value_init.hpp: VC 7.1 ICE & workaround" [SVN r39308]	2007-09-16 09:33:34 +00:00
Ralf W. Grosse-Kunstleve	01e91a3799	work around Visual C++ 7.1 internal compiler error [SVN r39302]	2007-09-15 23:11:50 +00:00
Niels Dekker	55f3c351a3	Added MSVC workaround to value_initialized, as described by ticket #1217 , proposed at the Boost Developers mailing list, and discussed with Fernando Cacciola. [SVN r39157]	2007-09-07 17:17:09 +00:00
Vladimir Prus	3f72b10182	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Eric Niebler	71cb8cb574	broken msvc name look-up getting confused about which detail namespace [SVN r38511]	2007-08-08 18:05:24 +00:00
Tobias Schwinger	c950825ef4	- overloads apply for array construction - adds support for zero arguments - lets apply return the result of the new-expression - revises the preprocessing code [SVN r38101]	2007-06-26 23:07:25 +00:00
Douglas Gregor	66ca84a45d	Update result_of information [SVN r38024]	2007-06-18 12:48:37 +00:00
Daniel Frey	06404f7d39	Improved empty_base [SVN r37754]	2007-05-23 22:48:42 +00:00
Douglas Gregor	2d860e2574	Fix result_of's handling of F(void). [SVN r37140]	2007-03-05 15:25:16 +00:00
Eric Niebler	66514f61ff	fix result_of ambiguity error for nullary functions [SVN r36773]	2007-01-24 06:44:20 +00:00
Eric Niebler	63cde4d3fd	slightly modified implementation works around msvc 7.1/8.0 compiler bugs [SVN r36668]	2007-01-08 20:38:51 +00:00
Daniel James	1950f292df	Merge fixed links from RC_1_34_0. [SVN r36660]	2007-01-07 23:50:56 +00:00
Andreas Huber	92a0602190	Fixed license & copyright issues and converted to HTML 4.01 [SVN r36280]	2006-12-05 21:11:21 +00:00
Peter Dimov	c9a3ab1d04	Linked to current_function.html [SVN r36268]	2006-12-04 20:31:38 +00:00
Vladimir Prus	0782034333	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 r35989]	2006-11-10 19:09:56 +00:00
Peter Dimov	0808883f3c	License/copyright edits [SVN r35958]	2006-11-09 20:34:33 +00:00
Beman Dawes	2f69501e55	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
John Maddock	5b83f641a8	Removed unneeded semicolon. [SVN r35636]	2006-10-16 18:01:40 +00:00
Dave Abrahams	c730ab4ffb	Parameter library Workarounds for Borland and MSVC Parameter library explicit markup for expected failures value_init.hpp: Borland workarounds Use angle-includes consistently [SVN r35084]	2006-09-13 03:00:18 +00:00
Fernando Cacciola	e55610a0d0	Some additional functions added to optional (being new there won't be regressions) [SVN r34411]	2006-06-26 18:01:38 +00:00
Hartmut Kaiser	bf968794c9	Fixed an ambiguity. [SVN r34403]	2006-06-26 01:58:38 +00:00
Peter Dimov	ce6e9c6698	Digital Mars support (Pavel Vozenilek) [SVN r34373]	2006-06-22 12:47:19 +00:00
Dave Abrahams	7ac180ed54	Use forwarding to get SFINAE effect in some common use cases. Rename detail::result_of to detail::result_of_impl to avoid surprises when result_of is used from within boost::detail. [SVN r33981]	2006-05-16 22:55:27 +00:00