This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'. [SVN r26264]
fix main return type
2025-10-04 19:51:02 +02:00 · 2004-11-19 19:19:18 +00:00 · 2004-11-02 05:14:24 +00:00 · 2004-10-20 08:26:43 +00:00 · 2004-10-05 15:45:52 +00:00 · 2004-08-29 10:29:46 +00:00
64 changed files with 9262 additions and 1274 deletions
--- a/compatibility.htm
+++ b/compatibility.htm
@@ -9,7 +9,7 @@

 <body bgcolor="#FFFFFF" text="#000000">

-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">Smart
+<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86">Smart
 Pointer Changes</h1>

 <p>The February 2002 change to the Boost smart pointers introduced a number
--- a/enable_shared_from_this.html
+++ b/enable_shared_from_this.html
@@ -0,0 +1,93 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+	<head>
+		<title>Boost: enable_shared_from_this.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">
+					<img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86">
+				</td>
+				<td align="middle">
+					<h1>enable_shared_from_this.hpp</h1>
+				</td>
+			</tr>
+			<tr>
+				<td colspan="2" height="64">&nbsp;</td>
+			</tr>
+		</table>
+		<h3><a name="Purpose">Purpose</a></h3>
+		<p>
+			The header <STRONG>&lt;boost/enable_shared_from_this.hpp&gt;</STRONG> defines 
+			the class template <STRONG>enable_shared_from_this</STRONG>. It is used as a 
+			base class that allows a <A href="shared_ptr.htm">shared_ptr</A> to the current 
+			object to be obtained from within a member function.
+		</p>
+		<P><STRONG>enable_shared_from_this&lt;T&gt;</STRONG> defines two member functions 
+			called <STRONG>shared_from_this</STRONG> that return a <STRONG>shared_ptr&lt;T&gt;</STRONG>
+			and <STRONG>shared_ptr&lt;T const&gt;</STRONG>, depending on constness, to <STRONG>this</STRONG>.</P>
+		<h3><a name="Example">Example</a></h3>
+		<pre>
+class Y: public enable_shared_from_this&lt;Y&gt;
+{
+public:
+
+    shared_ptr&lt;Y&gt; f()
+    {
+        return shared_from_this();
+    }
+}
+
+int main()
+{
+    shared_ptr&lt;Y&gt; p(new Y);
+    shared_ptr&lt;Y&gt; q = p-&gt;f();
+    assert(p == q);
+    assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
+}
+</pre>
+		<h3><a name="Synopsis">Synopsis</a></h3>
+		<pre>
+namespace boost
+{
+
+template&lt;class T&gt; class enable_shared_from_this
+{
+public:
+
+    shared_ptr&lt;T&gt; shared_from_this();
+    shared_ptr&lt;T const&gt; shared_from_this() const;
+}
+
+}
+</pre>
+		<h4>template&lt;class T&gt; shared_ptr&lt;T&gt; 
+			enable_shared_from_this&lt;T&gt;::shared_from_this();</h4>
+		<h4>template&lt;class T&gt; shared_ptr&lt;T const&gt; 
+			enable_shared_from_this&lt;T&gt;::shared_from_this() const;</h4>
+		<blockquote>
+			<p>
+				<b>Requires:</b> <STRONG>enable_shared_from_this&lt;T&gt;</STRONG> must be an 
+				accessible base class of <b>T</b>. <STRONG>*this</STRONG> must be a subobject 
+				of an instance <STRONG>t</STRONG> of type <STRONG>T</STRONG> . There must exist 
+				at least one <STRONG>shared_ptr</STRONG> instance <STRONG>p</STRONG> that <EM>owns</EM>
+				<STRONG>t</STRONG>.
+			</p>
+			<p>
+				<b>Returns:</b> A <b>shared_ptr&lt;T&gt;</b> instance <b>r</b> that shares 
+				ownership with <b>p</b>.
+			</p>
+			<p>
+				<b>Postconditions:</b> <tt>r.get() == this</tt>.
+			</p>
+		</blockquote>
+		<p>
+			<br>
+			<small>Copyright <20> 2002, 2003 by Peter Dimov. 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.</small></p>
+	</body>
+</html>
--- a/example/scoped_ptr_example.cpp
+++ b/example/scoped_ptr_example.cpp
@@ -1,5 +1,12 @@
 // Boost scoped_ptr_example implementation file  -----------------------------//

+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
 #include "scoped_ptr_example.hpp"
 #include <iostream>

--- a/example/scoped_ptr_example.hpp
+++ b/example/scoped_ptr_example.hpp
@@ -1,5 +1,12 @@
 //  Boost scoped_ptr_example header file  ------------------------------------//

+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
 #include <boost/utility.hpp>
 #include <boost/scoped_ptr.hpp>

--- a/example/scoped_ptr_example_test.cpp
+++ b/example/scoped_ptr_example_test.cpp
@@ -0,0 +1,17 @@
+// Boost scoped_ptr_example_test main program  -------------------------------//
+
+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "scoped_ptr_example.hpp"
+
+int main()
+{
+  example my_example;
+  my_example.do_something();
+  return 0;
+}
--- a/example/shared_ptr_example.cpp
+++ b/example/shared_ptr_example.cpp
@@ -1,12 +1,11 @@
 //  Boost shared_ptr_example.cpp  --------------------------------------------//

-//  (C) Copyright Beman Dawes 2001. 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 Beman Dawes 2001.  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)

-//  See http://www.boost.org for most recent version including documentation.
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.

 //  Revision History
 //  21 May 01  Initial complete version (Beman Dawes)
--- a/example/shared_ptr_example2.cpp
+++ b/example/shared_ptr_example2.cpp
@@ -1,5 +1,12 @@
 // Boost shared_ptr_example2 implementation file  -----------------------------//

+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
 #include "shared_ptr_example2.hpp"
 #include <iostream>

@@ -10,10 +17,6 @@ class example::implementation
 };

 example::example() : _imp( new implementation ) {}
-example::example( const example & s ) : _imp( s._imp ) {}
-
-example & example::operator=( const example & s )
-  { _imp = s._imp; return *this; }

 void example::do_something()
  { std::cout << "use_count() is " << _imp.use_count() << "\n"; }
--- a/example/shared_ptr_example2.hpp
+++ b/example/shared_ptr_example2.hpp
@@ -1,5 +1,12 @@
 //  Boost shared_ptr_example2 header file  -----------------------------------//

+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
 #include <boost/shared_ptr.hpp>

 //  This example demonstrates the handle/body idiom (also called pimpl and
@@ -14,12 +21,10 @@

 class example
 {
- public:
+public:
  example();
-  example( const example & );
-  example & operator=( const example & );
  void do_something();
- private:
+private:
  class implementation;
  boost::shared_ptr< implementation > _imp; // hide implementation details
 };
--- a/example/shared_ptr_example2_test.cpp
+++ b/example/shared_ptr_example2_test.cpp
@@ -1,5 +1,12 @@
 // Boost shared_ptr_example2_test main program  ------------------------------//

+//  Copyright Beman Dawes 2001.  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)
+
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.
+
 #include "shared_ptr_example2.hpp"

 int main()
--- a/include/boost/detail/atomic_count.hpp
+++ b/include/boost/detail/atomic_count.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //
 //  typedef <implementation-defined> boost::detail::atomic_count;
 //
@@ -104,19 +105,8 @@ typedef long atomic_count;
 #  include <boost/detail/atomic_count_pthreads.hpp>
 #else

-// #warning Unrecognized platform, detail::atomic_count will not be thread safe
-
-namespace boost
-{
-
-namespace detail
-{
-
-typedef long atomic_count;
-
-}
-
-}
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+#error Unrecognized threading platform

 #endif

--- a/include/boost/detail/atomic_count_gcc.hpp
+++ b/include/boost/detail/atomic_count_gcc.hpp
@@ -11,10 +11,9 @@
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
 //
-//  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.
+//  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 <bits/atomicity.h>
@@ -38,7 +37,7 @@ public:

    long operator--()
    {
-        return !__exchange_and_add(&value_, -1);
+        return __exchange_and_add(&value_, -1) - 1;
    }

    operator long() const
@@ -51,7 +50,7 @@ private:
    atomic_count(atomic_count const &);
    atomic_count & operator=(atomic_count const &);

-    _Atomic_word value_;
+    mutable _Atomic_word value_;
 };

 } // namespace detail
--- a/include/boost/detail/atomic_count_linux.hpp
+++ b/include/boost/detail/atomic_count_linux.hpp
@@ -6,10 +6,9 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //

 //
--- a/include/boost/detail/atomic_count_pthreads.hpp
+++ b/include/boost/detail/atomic_count_pthreads.hpp
@@ -6,10 +6,9 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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 <pthread.h>
--- a/include/boost/detail/atomic_count_win32.hpp
+++ b/include/boost/detail/atomic_count_win32.hpp
@@ -1,22 +1,25 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  boost/detail/atomic_count_win32.hpp
 //
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
-//  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.
+// 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/winapi.hpp>
+#ifdef BOOST_USE_WINDOWS_H
+#  include <windows.h>
+#endif

 namespace boost
 {
@@ -24,6 +27,37 @@ namespace boost
 namespace detail
 {

+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedIncrement(long volatile *);
+extern "C" long_type __cdecl _InterlockedDecrement(long volatile *);
+
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+
+inline long InterlockedIncrement(long volatile * lp)
+{ 
+    return _InterlockedIncrement(lp);
+}
+
+inline long InterlockedDecrement(long volatile* lp)
+{ 
+    return _InterlockedDecrement(lp);
+}
+
+#else  // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement(long volatile *);
+extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement(long volatile *);
+
+#endif // _WIN64
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
 class atomic_count
 {
 public:
@@ -34,12 +68,13 @@ public:

    long operator++()
    {
-        return winapi::InterlockedIncrement(&value_);
+        // Some older <windows.h> versions do not accept volatile
+        return InterlockedIncrement(const_cast<long*>(&value_));
    }

    long operator--()
    {
-        return winapi::InterlockedDecrement(&value_);
+        return InterlockedDecrement(const_cast<long*>(&value_));
    }

    operator long() const
--- a/include/boost/detail/lightweight_mutex.hpp
+++ b/include/boost/detail/lightweight_mutex.hpp
@@ -1,19 +1,20 @@
 #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 #define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  boost/detail/lightweight_mutex.hpp - lightweight mutex
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //
 //  typedef <unspecified> boost::detail::lightweight_mutex;
 //
@@ -64,15 +65,23 @@
 //  shared_ptr_timing_test.cpp will compile succesfully with a stub do-nothing
 //  pthreads library, since it doesn't create any threads.

-#ifndef BOOST_HAS_THREADS
-#  include <boost/detail/lwm_nop.hpp>
+#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(BOOST_LWM_USE_CRITICAL_SECTION) && !defined(BOOST_LWM_USE_PTHREADS)
+# define BOOST_LWM_WIN32
+#endif
+
+#if !defined(BOOST_HAS_THREADS)
+#  if defined(BOOST_LWM_WIN32)
+#    include <boost/detail/lwm_win32_nt.hpp>
+#  else
+#    include <boost/detail/lwm_nop.hpp>
+#  endif
 #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H)
 #  include <boost/detail/lwm_linux.hpp>
 #elif defined(BOOST_LWM_USE_CRITICAL_SECTION)
 #  include <boost/detail/lwm_win32_cs.hpp>
 #elif defined(BOOST_LWM_USE_PTHREADS)
 #  include <boost/detail/lwm_pthreads.hpp>
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#elif defined(BOOST_LWM_WIN32)
 #  include <boost/detail/lwm_win32.hpp>
 #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi)
 #  include <boost/detail/lwm_irix.hpp>
@@ -82,7 +91,8 @@
 #  define BOOST_LWM_USE_PTHREADS
 #  include <boost/detail/lwm_pthreads.hpp>
 #else
-#  include <boost/detail/lwm_nop.hpp>
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+#  error Unrecognized threading platform
 #endif

 #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
--- a/include/boost/detail/lwm_gcc.hpp
+++ b/include/boost/detail/lwm_gcc.hpp
@@ -11,10 +11,9 @@
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
 //
-//  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.
+//  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 <bits/atomicity.h>
@@ -37,7 +36,7 @@ private:

 public:

-    lightweight_mutex(): a_(1)
+    lightweight_mutex(): a_(0)
    {
    }

@@ -57,16 +56,16 @@ public:

        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
-            while( !__exchange_and_add(&m_.a_, -1) )
+            while( __exchange_and_add(&m_.a_, 1) )
            {
-                __atomic_add(&m_.a_, 1);
+                __atomic_add(&m_.a_, -1);
                sched_yield();
            }
        }

        ~scoped_lock()
        {
-            __atomic_add(&m_.a_, 1);
+            __atomic_add(&m_.a_, -1);
        }
    };
 };
--- a/include/boost/detail/lwm_irix.hpp
+++ b/include/boost/detail/lwm_irix.hpp
@@ -1,20 +1,15 @@
 #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
 //
 //  boost/detail/lwm_irix.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Dan Gohman
 //
-//  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.
+// 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 <sgidefs.h>
--- a/include/boost/detail/lwm_linux.hpp
+++ b/include/boost/detail/lwm_linux.hpp
@@ -1,19 +1,14 @@
 #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
 //
 //  boost/detail/lwm_linux.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //

 //
--- a/include/boost/detail/lwm_nop.hpp
+++ b/include/boost/detail/lwm_nop.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //

 namespace boost
--- a/include/boost/detail/lwm_pthreads.hpp
+++ b/include/boost/detail/lwm_pthreads.hpp
@@ -1,8 +1,10 @@
 #ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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 <pthread.h>
--- a/include/boost/detail/lwm_win32.hpp
+++ b/include/boost/detail/lwm_win32.hpp
@@ -1,22 +1,25 @@
 #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  boost/detail/lwm_win32.hpp
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2003 Peter Dimov
 //
-//  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.
+// 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/winapi.hpp>
+#ifdef BOOST_USE_WINDOWS_H
+#  include <windows.h>
+#endif

 #ifdef __BORLANDC__
 # pragma warn -8027     // Functions containing while are not expanded inline
@@ -28,6 +31,31 @@ namespace boost
 namespace detail
 {

+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedExchange(long volatile *, long);
+
+#pragma intrinsic(_InterlockedExchange)
+
+inline long InterlockedExchange(long volatile* lp, long l)
+{
+    return _InterlockedExchange(lp, l);
+}
+
+#else  // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchange(long volatile *, long);
+
+#endif // _WIN64
+
+extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
 class lightweight_mutex
 {
 private:
@@ -59,20 +87,20 @@ public:

        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
-            while( winapi::InterlockedExchange(&m_.l_, 1) )
+            while( InterlockedExchange(&m_.l_, 1) )
            {
                // Note: changed to Sleep(1) from Sleep(0).
                // According to MSDN, Sleep(0) will never yield
                // to a lower-priority thread, whereas Sleep(1)
                // will. Performance seems not to be affected.

-                winapi::Sleep(1);
+                Sleep(1);
            }
        }

        ~scoped_lock()
        {
-            winapi::InterlockedExchange(&m_.l_, 0);
+            InterlockedExchange(&m_.l_, 0);

            // Note: adding a yield here will make
            // the spinlock more fair and will increase the overall
--- a/include/boost/detail/lwm_win32_cs.hpp
+++ b/include/boost/detail/lwm_win32_cs.hpp
@@ -1,22 +1,25 @@
 #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
 #define BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  boost/detail/lwm_win32_cs.hpp
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2003 Peter Dimov
 //
-//  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.
+// 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/winapi.hpp>
+#ifdef BOOST_USE_WINDOWS_H
+#  include <windows.h>
+#endif

 namespace boost
 {
@@ -24,11 +27,34 @@ namespace boost
 namespace detail
 {

+#ifndef BOOST_USE_WINDOWS_H
+
+struct CRITICAL_SECTION
+{
+    struct critical_section_debug * DebugInfo;
+    long LockCount;
+    long RecursionCount;
+    void * OwningThread;
+    void * LockSemaphore;
+#if defined(_WIN64)
+    unsigned __int64 SpinCount;
+#else
+    unsigned long SpinCount;
+#endif
+};
+
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(CRITICAL_SECTION *);
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
 class lightweight_mutex
 {
 private:

-    winapi::critical_section cs_;
+    CRITICAL_SECTION cs_;

    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
@@ -37,12 +63,12 @@ public:

    lightweight_mutex()
    {
-        winapi::InitializeCriticalSection(&cs_);
+        InitializeCriticalSection(&cs_);
    }

    ~lightweight_mutex()
    {
-        winapi::DeleteCriticalSection(&cs_);
+        DeleteCriticalSection(&cs_);
    }

    class scoped_lock;
@@ -61,12 +87,12 @@ public:

        explicit scoped_lock(lightweight_mutex & m): m_(m)
        {
-            winapi::EnterCriticalSection(&m_.cs_);
+            EnterCriticalSection(&m_.cs_);
        }

        ~scoped_lock()
        {
-            winapi::LeaveCriticalSection(&m_.cs_);
+            LeaveCriticalSection(&m_.cs_);
        }
    };
 };
--- a/include/boost/detail/lwm_win32_nt.hpp
+++ b/include/boost/detail/lwm_win32_nt.hpp
@@ -0,0 +1,63 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/lwm_win32_nt.hpp
+//
+//  Copyright (c) 2002, 2003 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)
+//
+//  "No threads" version of lwm_win32.hpp; binary compatible but no-op.
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    long l_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): l_(0)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex &)
+        {
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
--- a/include/boost/detail/shared_array_nmt.hpp
+++ b/include/boost/detail/shared_array_nmt.hpp
@@ -7,10 +7,9 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+//  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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 //
--- a/include/boost/detail/shared_count.hpp
+++ b/include/boost/detail/shared_count.hpp
@@ -1,34 +1,42 @@
 #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
 #define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED

-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif

 //
 //  detail/shared_count.hpp
 //
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/config.hpp>

-#ifndef BOOST_NO_AUTO_PTR
-# include <memory>
+#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
 #endif

 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/lightweight_mutex.hpp>

-#include <functional>       // for std::less
-#include <exception>        // for std::exception
-#include <new>              // for std::bad_alloc
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
+
+#include <memory>           // std::auto_ptr, std::allocator
+#include <functional>       // std::less
+#include <exception>        // std::exception
+#include <new>              // std::bad_alloc
+#include <typeinfo>         // std::type_info in get_deleter
+#include <cstddef>          // std::size_t

 #ifdef __BORLANDC__
 # pragma warn -8026     // Functions with excep. spec. are not expanded inline
@@ -38,9 +46,21 @@
 namespace boost
 {

+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
 // The standard library that comes with Borland C++ 5.5.1
 // defines std::exception and its members as having C calling
-// convention (-pc). When the definition of use_count_is_zero
+// convention (-pc). When the definition of bad_weak_ptr
 // is compiled with -ps, the compiler issues an error.
 // Hence, the temporary #pragma option -pc below. The version
 // check is deliberately conservative.
@@ -49,13 +69,13 @@ namespace boost
 # pragma option push -pc
 #endif

-class use_count_is_zero: public std::exception
+class bad_weak_ptr: public std::exception
 {
 public:

    virtual char const * what() const throw()
    {
-        return "boost::use_count_is_zero";
+        return "boost::bad_weak_ptr";
    }
 };

@@ -63,7 +83,10 @@ public:
 # pragma option pop
 #endif

-class counted_base
+namespace detail
+{
+
+class sp_counted_base
 {
 private:

@@ -71,34 +94,18 @@ private:

 public:

-    counted_base():
-        use_count_(0), weak_count_(0)
+    sp_counted_base(): use_count_(1), weak_count_(1)
    {
    }

-    // pre: initial_use_count <= initial_weak_count
-
-    explicit counted_base(long initial_use_count, long initial_weak_count):
-        use_count_(initial_use_count), weak_count_(initial_weak_count)
-    {
-    }
-
-    virtual ~counted_base() // nothrow
+    virtual ~sp_counted_base() // nothrow
    {
    }

    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.
-    //
-    // counted_base doesn't manage any resources except itself, and
-    // the default implementation is a no-op.
-    //
-    // dispose() is not pure virtual since weak_ptr instantiates a
-    // counted_base in its default constructor.

-    virtual void dispose() // nothrow
-    {
-    }
+    virtual void dispose() = 0; // nothrow

    // destruct() is called when weak_count_ drops to zero.

@@ -107,43 +114,43 @@ public:
        delete this;
    }

-    void add_ref()
+    virtual void * get_deleter(std::type_info const & ti) = 0;
+
+    void add_ref_copy()
    {
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS)
        mutex_type::scoped_lock lock(mtx_);
 #endif
-        if(use_count_ == 0 && weak_count_ != 0) boost::throw_exception(boost::use_count_is_zero());
        ++use_count_;
-        ++weak_count_;
+    }
+
+    void add_ref_lock()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr());
+        ++use_count_;
    }

    void release() // nothrow
    {
-        long new_use_count;
-        long new_weak_count;
-
        {
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS)
            mutex_type::scoped_lock lock(mtx_);
 #endif
-            new_use_count = --use_count_;
-            new_weak_count = --weak_count_;
+            long new_use_count = --use_count_;
+
+            if(new_use_count != 0) return;
        }

-        if(new_use_count == 0)
-        {
-            dispose();
-        }
-
-        if(new_weak_count == 0)
-        {
-            destruct();
-        }
+        dispose();
+        weak_release();
    }

    void weak_add_ref() // nothrow
    {
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS)
        mutex_type::scoped_lock lock(mtx_);
 #endif
        ++weak_count_;
@@ -154,7 +161,7 @@ public:
        long new_weak_count;

        {
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS)
            mutex_type::scoped_lock lock(mtx_);
 #endif
            new_weak_count = --weak_count_;
@@ -168,7 +175,7 @@ public:

    long use_count() const // nothrow
    {
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS)
        mutex_type::scoped_lock lock(mtx_);
 #endif
        return use_count_;
@@ -176,94 +183,161 @@ public:

 private:

-    counted_base(counted_base const &);
-    counted_base & operator= (counted_base const &);
+    sp_counted_base(sp_counted_base const &);
+    sp_counted_base & operator= (sp_counted_base const &);

-    // inv: use_count_ <= weak_count_
+    long use_count_;        // #shared
+    long weak_count_;       // #weak + (#shared != 0)

-    long use_count_;
-    long weak_count_;
-
-#ifdef BOOST_HAS_THREADS
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
    mutable mutex_type mtx_;
 #endif
 };

-inline void intrusive_ptr_add_ref(counted_base * p)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
 {
-    p->add_ref();
+    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
 }

-inline void intrusive_ptr_release(counted_base * p)
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
 {
-    p->release();
+    boost::sp_array_constructor_hook(px);
 }

-namespace detail
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
 {
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif

 //
 // Borland's Codeguard trips up over the -Vx- option here:
 //
 #ifdef __CODEGUARD__
-#pragma option push -Vx-
+# pragma option push -Vx-
 #endif

-template<class P, class D> class counted_base_impl: public counted_base
+template<class P, class D> class sp_counted_base_impl: public sp_counted_base
 {
 private:

    P ptr; // copy constructor must not throw
    D del; // copy constructor must not throw

-    counted_base_impl(counted_base_impl const &);
-    counted_base_impl & operator= (counted_base_impl const &);
+    sp_counted_base_impl(sp_counted_base_impl const &);
+    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+    typedef sp_counted_base_impl<P, D> this_type;

 public:

    // pre: initial_use_count <= initial_weak_count, d(p) must not throw

-    counted_base_impl(P p, D d, long initial_use_count, long initial_weak_count):
-        counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
+    sp_counted_base_impl(P p, D d): ptr(p), del(d)
    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
    }

    virtual void dispose() // nothrow
    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
        del(ptr);
    }
+
+    virtual void * get_deleter(std::type_info const & ti)
+    {
+        return ti == typeid(D)? &del: 0;
+    }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
+    }
+
+    void operator delete(void * p)
+    {
+        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
+    }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete(void * p)
+    {
+        quick_allocator<this_type>::dealloc(p);
+    }
+
+#endif
 };

+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const   weak_count_id = 0x298C38A4;
+
+#endif
+
 class weak_count;

 class shared_count
 {
 private:

-    counted_base * pi_;
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif

    friend class weak_count;

-    template<class P, class D> shared_count(P, D, counted_base const *);
-
 public:

-    shared_count(): pi_(new counted_base(1, 1))
+    shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
    }

-    explicit shared_count(counted_base * pi): pi_(pi) // never throws
-    {
-        pi_->add_ref();
-    }
-
-    template<class P, class D> shared_count(P p, D d, void const * = 0): pi_(0)
+    template<class P, class D> shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
 #ifndef BOOST_NO_EXCEPTIONS

        try
        {
-            pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
+            pi_ = new sp_counted_base_impl<P, D>(p, d);
        }
        catch(...)
        {
@@ -273,7 +347,7 @@ public:

 #else

-        pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
+        pi_ = new sp_counted_base_impl<P, D>(p, d);

        if(pi_ == 0)
        {
@@ -284,17 +358,15 @@ public:
 #endif
    }

-    template<class P, class D> shared_count(P, D, counted_base * pi): pi_(pi)
-    {
-        pi_->add_ref();
-    }
-
 #ifndef BOOST_NO_AUTO_PTR

    // auto_ptr<Y> is special cased to provide the strong guarantee

-    template<typename Y>
-    explicit shared_count(std::auto_ptr<Y> & r): pi_(new counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>(), 1, 1))
+    template<class Y>
+    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
        r.release();
    }
@@ -303,41 +375,51 @@ public:

    ~shared_count() // nothrow
    {
-        pi_->release();
+        if(pi_ != 0) pi_->release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
    }

    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
-        pi_->add_ref();
+        if(pi_ != 0) pi_->add_ref_copy();
    }

-    explicit shared_count(weak_count const & r); // throws use_count_is_zero when r.use_count() == 0
+    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0

    shared_count & operator= (shared_count const & r) // nothrow
    {
-        counted_base * tmp = r.pi_;
-        tmp->add_ref();
-        pi_->release();
-        pi_ = tmp;
+        sp_counted_base * tmp = r.pi_;
+
+        if(tmp != pi_)
+        {
+            if(tmp != 0) tmp->add_ref_copy();
+            if(pi_ != 0) pi_->release();
+            pi_ = tmp;
+        }

        return *this;
    }

    void swap(shared_count & r) // nothrow
    {
-        counted_base * tmp = r.pi_;
+        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const // nothrow
    {
-        return pi_->use_count();
+        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const // nothrow
    {
-        return pi_->use_count() == 1;
+        return use_count() == 1;
    }

    friend inline bool operator==(shared_count const & a, shared_count const & b)
@@ -347,12 +429,17 @@ public:

    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
-        return std::less<counted_base *>()(a.pi_, b.pi_);
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+
+    void * get_deleter(std::type_info const & ti) const
+    {
+        return pi_? pi_->get_deleter(ti): 0;
    }
 };

 #ifdef __CODEGUARD__
-#pragma option pop
+# pragma option pop
 #endif


@@ -360,36 +447,52 @@ class weak_count
 {
 private:

-    counted_base * pi_;
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif

    friend class shared_count;

 public:

-    weak_count(): pi_(new counted_base(0, 1)) // can throw
+    weak_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(weak_count_id)
+#endif
    {
    }

    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
-        pi_->weak_add_ref();
+        if(pi_ != 0) pi_->weak_add_ref();
    }

    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
    {
-        pi_->weak_add_ref();
+        if(pi_ != 0) pi_->weak_add_ref();
    }

    ~weak_count() // nothrow
    {
-        pi_->weak_release();
+        if(pi_ != 0) pi_->weak_release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
    }

    weak_count & operator= (shared_count const & r) // nothrow
    {
-        counted_base * tmp = r.pi_;
-        tmp->weak_add_ref();
-        pi_->weak_release();
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
        pi_ = tmp;

        return *this;
@@ -397,9 +500,9 @@ public:

    weak_count & operator= (weak_count const & r) // nothrow
    {
-        counted_base * tmp = r.pi_;
-        tmp->weak_add_ref();
-        pi_->weak_release();
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
        pi_ = tmp;

        return *this;
@@ -407,14 +510,14 @@ public:

    void swap(weak_count & r) // nothrow
    {
-        counted_base * tmp = r.pi_;
+        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const // nothrow
    {
-        return pi_->use_count();
+        return pi_ != 0? pi_->use_count(): 0;
    }

    friend inline bool operator==(weak_count const & a, weak_count const & b)
@@ -424,13 +527,23 @@ public:

    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
-        return std::less<counted_base *>()(a.pi_, b.pi_);
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
 };

 inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
 {
-    pi_->add_ref();
+    if(pi_ != 0)
+    {
+        pi_->add_ref_lock();
+    }
+    else
+    {
+        boost::throw_exception(boost::bad_weak_ptr());
+    }
 }

 } // namespace detail
--- a/include/boost/detail/shared_ptr_nmt.hpp
+++ b/include/boost/detail/shared_ptr_nmt.hpp
@@ -7,10 +7,9 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+//  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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 //
--- a/include/boost/detail/winapi.hpp
+++ b/include/boost/detail/winapi.hpp
@@ -1,106 +0,0 @@
-#ifndef BOOST_DETAIL_WINAPI_HPP_INCLUDED
-#define BOOST_DETAIL_WINAPI_HPP_INCLUDED
-
-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
-//
-//  boost/detail/winapi.hpp - a lightweight version of <windows.h>
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-//  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.
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-namespace winapi
-{
-
-typedef long long_type;
-typedef unsigned long dword_type;
-typedef void * handle_type;
-
-#if defined(_WIN64)
-
-typedef __int64 int_ptr_type;
-typedef unsigned __int64 uint_ptr_type;
-typedef __int64 long_ptr_type;
-typedef unsigned __int64 ulong_ptr_type;
-
-#else
-
-typedef int int_ptr_type;
-typedef unsigned int uint_ptr_type;
-typedef long long_ptr_type;
-typedef unsigned long ulong_ptr_type;
-
-#endif
-
-struct critical_section
-{
-    struct critical_section_debug * DebugInfo;
-    long_type LockCount;
-    long_type RecursionCount;
-    handle_type OwningThread;
-    handle_type LockSemaphore;
-    ulong_ptr_type SpinCount;
-};
-
-#if defined(_WIN64)
-
-// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
-
-extern "C" long_type __cdecl _InterlockedIncrement(long_type volatile *);
-extern "C" long_type __cdecl _InterlockedDecrement(long_type volatile *);
-extern "C" long_type __cdecl _InterlockedExchange(long_type volatile *, long_type);
-
-#pragma intrinsic(_InterlockedIncrement)
-#pragma intrinsic(_InterlockedDecrement)
-#pragma intrinsic(_InterlockedExchange)
-
-inline long_type InterlockedIncrement(long_type volatile * lp)
-{ 
-    return _InterlockedIncrement(lp);
-}
-
-inline long_type InterlockedDecrement(long_type volatile* lp)
-{ 
-    return _InterlockedDecrement(lp);
-}
-
-inline long_type InterlockedExchange(long_type volatile* lp, long_type l)
-{
-    return _InterlockedExchange(lp, l);
-}
-
-#else
-
-extern "C" __declspec(dllimport) long_type __stdcall InterlockedIncrement(long_type volatile *);
-extern "C" __declspec(dllimport) long_type __stdcall InterlockedDecrement(long_type volatile *);
-extern "C" __declspec(dllimport) long_type __stdcall InterlockedExchange(long_type volatile *, long_type);
-
-#endif
-
-extern "C" __declspec(dllimport) void __stdcall Sleep(dword_type);
-
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
-
-} // namespace winapi
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_WINAPI_HPP_INCLUDED
--- a/include/boost/enable_shared_from_this.hpp
+++ b/include/boost/enable_shared_from_this.hpp
@@ -0,0 +1,67 @@
+#ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+//
+//  enable_shared_from_this.hpp
+//
+//  Copyright (c) 2002 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)
+//
+//  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//
+
+#include <boost/weak_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+template<class T> class enable_shared_from_this
+{
+protected:
+
+    enable_shared_from_this()
+    {
+    }
+
+    enable_shared_from_this(enable_shared_from_this const &)
+    {
+    }
+
+    enable_shared_from_this & operator=(enable_shared_from_this const &)
+    {
+        return *this;
+    }
+
+    ~enable_shared_from_this()
+    {
+    }
+
+public:
+
+    shared_ptr<T> shared_from_this()
+    {
+        shared_ptr<T> p(_internal_weak_this);
+        BOOST_ASSERT(p.get() == this);
+        return p;
+    }
+
+    shared_ptr<T const> shared_from_this() const
+    {
+        shared_ptr<T const> p(_internal_weak_this);
+        BOOST_ASSERT(p.get() == this);
+        return p;
+    }
+
+    typedef T _internal_element_type; // for bcc 5.5.1
+    mutable weak_ptr<_internal_element_type> _internal_weak_this;
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
--- a/include/boost/get_pointer.hpp
+++ b/include/boost/get_pointer.hpp
@@ -0,0 +1,29 @@
+// Copyright Peter Dimov and David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef GET_POINTER_DWA20021219_HPP
+# define GET_POINTER_DWA20021219_HPP
+
+# include <memory>
+
+namespace boost { 
+
+// get_pointer(p) extracts a ->* capable pointer from p
+
+template<class T> T * get_pointer(T * p)
+{
+    return p;
+}
+
+// get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
+
+template<class T> T * get_pointer(std::auto_ptr<T> const& p)
+{
+    return p.get();
+}
+
+
+} // namespace boost
+
+#endif // GET_POINTER_DWA20021219_HPP
--- a/include/boost/intrusive_ptr.hpp
+++ b/include/boost/intrusive_ptr.hpp
@@ -6,20 +6,26 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+// 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
 //

+#include <boost/config.hpp>
+
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
 # pragma warning(disable:4284) // odd return type for operator->
 #endif

-#include <functional> // std::less
+#include <boost/assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <functional>           // for std::less
+#include <iosfwd>               // for std::basic_ostream
+

 namespace boost
 {
@@ -47,18 +53,15 @@ private:

 public:

+    typedef T element_type;
+
    intrusive_ptr(): p_(0)
    {
    }

-    intrusive_ptr(T * p): p_(p)
+    intrusive_ptr(T * p, bool add_ref = true): p_(p)
    {
-        if(p_ != 0) intrusive_ptr_add_ref(p_);
-    }
-
-    ~intrusive_ptr()
-    {
-        if(p_ != 0) intrusive_ptr_release(p_);
+        if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_);
    }

 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
@@ -75,6 +78,11 @@ public:
        if(p_ != 0) intrusive_ptr_add_ref(p_);
    }

+    ~intrusive_ptr()
+    {
+        if(p_ != 0) intrusive_ptr_release(p_);
+    }
+
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)

    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
@@ -97,13 +105,6 @@ public:
        return *this;
    }

-    void swap(intrusive_ptr & rhs)
-    {
-        T * tmp = p_;
-        p_ = rhs.p_;
-        rhs.p_ = tmp;
-    }
-
    T * get() const
    {
        return p_;
@@ -119,16 +120,43 @@ public:
        return p_;
    }

-    bool empty() const
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+    operator bool () const
+    {
+        return p_ != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
+    operator unspecified_bool_type() const // never throws
+    {
+        return p_ == 0? 0: &this_type::get;
+    }
+
+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type () const
+    {
+        return p_ == 0? 0: &this_type::p_;
+    }
+
+#endif
+
+    // operator! is a Borland-specific workaround
+    bool operator! () const
    {
        return p_ == 0;
    }

-    typedef bool (intrusive_ptr::*bool_type) () const;
-
-    operator bool_type () const
+    void swap(intrusive_ptr & rhs)
    {
-        return p_ == 0? 0: &intrusive_ptr::empty;
+        T * tmp = p_;
+        p_ = rhs.p_;
+        rhs.p_ = tmp;
    }

 private:
@@ -136,21 +164,6 @@ private:
    T * p_;
 };

-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
-{
-    lhs.swap(rhs);
-}
-
-template<class T, class U> intrusive_ptr<T> shared_dynamic_cast(intrusive_ptr<U> const & p)
-{
-    return dynamic_cast<T *>(p.get());
-}
-
-template<class T, class U> intrusive_ptr<T> shared_static_cast(intrusive_ptr<U> const & p)
-{
-    return static_cast<T *>(p.get());
-}
-
 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
 {
    return a.get() == b.get();
@@ -161,11 +174,6 @@ template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, in
    return a.get() != b.get();
 }

-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
-{
-    return std::less<T *>(a.get(), b.get());
-}
-
 template<class T> inline bool operator==(intrusive_ptr<T> const & a, T * b)
 {
    return a.get() == b;
@@ -186,6 +194,27 @@ template<class T> inline bool operator!=(T * a, intrusive_ptr<T> const & b)
    return a != b.get();
 }

+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+
+// Resolve the ambiguity between our op!= and the one in rel_ops
+
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+{
+    return a.get() != b.get();
+}
+
+#endif
+
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+{
+    return std::less<T *>()(a.get(), b.get());
+}
+
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
+{
+    lhs.swap(rhs);
+}
+
 // mem_fn support

 template<class T> T * get_pointer(intrusive_ptr<T> const & p)
@@ -193,6 +222,47 @@ template<class T> T * get_pointer(intrusive_ptr<T> const & p)
    return p.get();
 }

+template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
+{
+    return static_cast<T *>(p.get());
+}
+
+template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
+{
+    return const_cast<T *>(p.get());
+}
+
+template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
+{
+    return dynamic_cast<T *>(p.get());
+}
+
+// operator<<
+
+#if defined(__GNUC__) &&  (__GNUC__ < 3)
+
+template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
+{
+    os << p.get();
+    return os;
+}
+
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
+# else
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
+# endif 
+{
+    os << p.get();
+    return os;
+}
+
+#endif
+
 } // namespace boost

 #ifdef BOOST_MSVC
--- a/include/boost/scoped_array.hpp
+++ b/include/boost/scoped_array.hpp
@@ -4,27 +4,38 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+//  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)
 //
-//  See http://www.boost.org/libs/smart_ptr/scoped_array.htm for documentation.
+//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
 //

 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/config.hpp>   // in case ptrdiff_t not in std
+
+#include <boost/detail/workaround.hpp>
+
 #include <cstddef>            // for std::ptrdiff_t

 namespace boost
 {

+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_array_constructor_hook(void * p);
+void sp_array_destructor_hook(void * p);
+
+#endif
+
 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.

-template<typename T> class scoped_array // noncopyable
+template<class T> class scoped_array // noncopyable
 {
 private:

@@ -41,20 +52,23 @@ public:

    explicit scoped_array(T * p = 0) : ptr(p) // never throws
    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_array_constructor_hook(ptr);
+#endif
    }

    ~scoped_array() // never throws
    {
-        checked_array_delete(ptr);
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_array_destructor_hook(ptr);
+#endif
+        boost::checked_array_delete(ptr);
    }

    void reset(T * p = 0) // never throws
    {
-        if (ptr != p)
-        {
-            checked_array_delete(ptr);
-            ptr = p;
-        }
+        BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
+        this_type(p).swap(*this);
    }

    T & operator[](std::ptrdiff_t i) const // never throws
@@ -71,13 +85,32 @@ public:

    // implicit conversion to "bool"

-    typedef T * (this_type::*unspecified_bool_type)() const;
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)

+    operator bool () const
+    {
+        return ptr != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
    operator unspecified_bool_type() const // never throws
    {
        return ptr == 0? 0: &this_type::get;
    }

+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return ptr == 0? 0: &this_type::ptr;
+    }
+
+#endif
+
    bool operator! () const // never throws
    {
        return ptr == 0;
--- a/include/boost/scoped_ptr.hpp
+++ b/include/boost/scoped_ptr.hpp
@@ -4,16 +4,16 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+//  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)
 //
-//  See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
+//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
 //

 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
+#include <boost/detail/workaround.hpp>

 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
@@ -22,12 +22,21 @@
 namespace boost
 {

+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * p);
+void sp_scalar_destructor_hook(void * p);
+
+#endif
+
 //  scoped_ptr mimics a built-in pointer except that it guarantees deletion
 //  of the object pointed to, either on destruction of the scoped_ptr or via
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
 //  use shared_ptr or std::auto_ptr if your needs are more complex.

-template<typename T> class scoped_ptr // noncopyable
+template<class T> class scoped_ptr // noncopyable
 {
 private:

@@ -44,27 +53,34 @@ public:

    explicit scoped_ptr(T * p = 0): ptr(p) // never throws
    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_scalar_constructor_hook(ptr);
+#endif
    }

 #ifndef BOOST_NO_AUTO_PTR

    explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release()) // never throws
    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_scalar_constructor_hook(ptr);
+#endif
    }

 #endif

    ~scoped_ptr() // never throws
    {
-        checked_delete(ptr);
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        boost::sp_scalar_destructor_hook(ptr);
+#endif
+        boost::checked_delete(ptr);
    }

    void reset(T * p = 0) // never throws
    {
-        if(ptr != p)
-        {
-            this_type(p).swap(*this);
-        }
+        BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
+        this_type(p).swap(*this);
    }

    T & operator*() const // never throws
@@ -86,13 +102,31 @@ public:

    // implicit conversion to "bool"

-    typedef T * (this_type::*unspecified_bool_type)() const;
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)

+    operator bool () const
+    {
+        return ptr != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
    operator unspecified_bool_type() const // never throws
    {
        return ptr == 0? 0: &this_type::get;
    }

+#else 
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return ptr == 0? 0: &this_type::ptr;
+    }
+
+#endif
+
    bool operator! () const // never throws
    {
        return ptr == 0;
@@ -106,14 +140,14 @@ public:
    }
 };

-template<typename T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
 {
    a.swap(b);
 }

 // get_pointer(p) is a generic way to say p.get()

-template<typename T> inline T * get_pointer(scoped_ptr<T> const & p)
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
 {
    return p.get();
 }
--- a/include/boost/shared_array.hpp
+++ b/include/boost/shared_array.hpp
@@ -7,10 +7,9 @@
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-//  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.
+//  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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 //
@@ -25,6 +24,7 @@
 #include <boost/checked_delete.hpp>

 #include <boost/detail/shared_count.hpp>
+#include <boost/detail/workaround.hpp>

 #include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
@@ -41,7 +41,7 @@ namespace boost
 //  is destroyed or reset.
 //

-template<typename T> class shared_array
+template<class T> class shared_array
 {
 private:

@@ -63,7 +63,7 @@ public:
    // shared_array will release p by calling d(p)
    //

-    template<typename D> shared_array(T * p, D d): px(p), pn(p, d)
+    template<class D> shared_array(T * p, D d): px(p), pn(p, d)
    {
    }

@@ -75,7 +75,7 @@ public:
        this_type(p).swap(*this);
    }

-    template <typename D> void reset(T * p, D d)
+    template <class D> void reset(T * p, D d)
    {
        this_type(p, d).swap(*this);
    }
@@ -94,13 +94,32 @@ public:

    // implicit conversion to "bool"

-    typedef T * (this_type::*unspecified_bool_type)() const;
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)

+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::get;
    }

+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+#endif
+
    bool operator! () const // never throws
    {
        return px == 0;
@@ -129,22 +148,22 @@ private:

 };  // shared_array

-template<typename T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() == b.get();
 }

-template<typename T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return a.get() != b.get();
 }

-template<typename T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
    return std::less<T*>()(a.get(), b.get());
 }

-template<typename T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
 {
    a.swap(b);
 }
--- a/include/boost/shared_ptr.hpp
+++ b/include/boost/shared_ptr.hpp
@@ -5,12 +5,11 @@
 //  shared_ptr.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  Copyright (c) 2001, 2002 Peter Dimov
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
-//  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.
+//  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)
 //
 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 //
@@ -25,11 +24,13 @@
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/shared_count.hpp>
+#include <boost/detail/workaround.hpp>

-#include <memory>             // for std::auto_ptr
-#include <algorithm>          // for std::swap
-#include <functional>         // for std::less
-#include <typeinfo>           // for std::bad_cast
+#include <memory>               // for std::auto_ptr
+#include <algorithm>            // for std::swap
+#include <functional>           // for std::less
+#include <typeinfo>             // for std::bad_cast
+#include <iosfwd>               // for std::basic_ostream

 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
@@ -39,14 +40,18 @@
 namespace boost
 {

+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+
 namespace detail
 {

 struct static_cast_tag {};
+struct const_cast_tag {};
 struct dynamic_cast_tag {};
 struct polymorphic_cast_tag {};

-template<typename T> struct shared_ptr_traits
+template<class T> struct shared_ptr_traits
 {
    typedef T & reference;
 };
@@ -63,8 +68,29 @@ template<> struct shared_ptr_traits<void const>
    typedef void reference;
 };

+template<> struct shared_ptr_traits<void volatile>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void const volatile>
+{
+    typedef void reference;
+};
+
 #endif

+// enable_shared_from_this support
+
+template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
+{
+    if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
+}
+
+inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
+{
+}
+
 } // namespace detail


@@ -76,29 +102,28 @@ template<> struct shared_ptr_traits<void const>
 //  is destroyed or reset.
 //

-template<typename T> class weak_ptr;
-template<typename T> class intrusive_ptr;
-
-template<typename T> class shared_ptr
+template<class T> class shared_ptr
 {
 private:

-    // Borland 5.5.1 specific workarounds
-//  typedef checked_deleter<T> deleter;
+    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;

 public:

    typedef T element_type;
    typedef T value_type;
+    typedef T * pointer;
+    typedef typename detail::shared_ptr_traits<T>::reference reference;

-    shared_ptr(): px(0), pn()
+    shared_ptr(): px(0), pn() // never throws in 1.30+
    {
    }

-    template<typename Y>
-    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
+    template<class Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
    {
+        detail::sp_enable_shared_from_this( pn, p, p );
    }

    //
@@ -107,45 +132,60 @@ public:
    // shared_ptr will release p by calling d(p)
    //

-    template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
+        detail::sp_enable_shared_from_this( pn, p, p );
    }

-//  generated copy constructor, assignment, destructor are fine
+//  generated copy constructor, assignment, destructor are fine...

-    template<typename Y>
-    explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
+//  except that Borland C++ has a bug, and g++ with -Wsynth warns
+#if defined(__BORLANDC__) || defined(__GNUC__)
+
+    shared_ptr & operator=(shared_ptr const & r) // never throws
    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
    }

-    template<typename Y>
+#endif
+
+    template<class Y>
+    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
+    {
+        // it is now safe to copy r.px, as pn(r.pn) did not throw
+        px = r.px;
+    }
+
+    template<class Y>
    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
    {
    }

-    template<typename Y>
-    shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
-    {
-    }
-
-    template<typename Y>
+    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }

-    template<typename Y>
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
-        if (px == 0) // need to allocate new counter -- the cast failed
+        if(px == 0) // need to allocate new counter -- the cast failed
        {
            pn = detail::shared_count();
        }
    }

-    template<typename Y>
+    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
-        if (px == 0)
+        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
@@ -153,16 +193,19 @@ public:

 #ifndef BOOST_NO_AUTO_PTR

-    template<typename Y>
-    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
+    template<class Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
+        Y * tmp = r.get();
+        pn = detail::shared_count(r);
+        detail::sp_enable_shared_from_this( pn, tmp, tmp );
    }

 #endif

 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)

-    template<typename Y>
+    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
@@ -174,7 +217,7 @@ public:

 #ifndef BOOST_NO_AUTO_PTR

-    template<typename Y>
+    template<class Y>
    shared_ptr & operator=(std::auto_ptr<Y> & r)
    {
        this_type(r).swap(*this);
@@ -183,23 +226,23 @@ public:

 #endif

-    void reset()
+    void reset() // never throws in 1.30+
    {
        this_type().swap(*this);
    }

-    template<typename Y> void reset(Y * p) // Y must be complete
+    template<class Y> void reset(Y * p) // Y must be complete
    {
        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
        this_type(p).swap(*this);
    }

-    template<typename Y, typename D> void reset(Y * p, D d)
+    template<class Y, class D> void reset(Y * p, D d)
    {
        this_type(p, d).swap(*this);
    }

-    typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
+    reference operator* () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return *px;
@@ -218,13 +261,34 @@ public:

    // implicit conversion to "bool"

-    typedef T * (this_type::*unspecified_bool_type)() const;
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)

+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
    operator unspecified_bool_type() const // never throws
    {
        return px == 0? 0: &this_type::get;
    }

+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+#endif
+
+    // operator! is redundant, but some compilers need it
+
    bool operator! () const // never throws
    {
        return px == 0;
@@ -246,6 +310,16 @@ public:
        pn.swap(other.pn);
    }

+    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+    {
+        return pn < rhs.pn;
+    }
+
+    void * _internal_get_deleter(std::type_info const & ti) const
+    {
+        return pn.get_deleter(ti);
+    }
+
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)

@@ -253,8 +327,8 @@ public:

 private:

-    template<typename Y> friend class shared_ptr;
-    template<typename Y> friend class weak_ptr;
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;


 #endif
@@ -264,12 +338,12 @@ private:

 };  // shared_ptr

-template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() == b.get();
 }

-template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
    return a.get() != b.get();
 }
@@ -278,39 +352,56 @@ template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a,

 // Resolve the ambiguity between our op!= and the one in rel_ops

-template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
    return a.get() != b.get();
 }

 #endif

-template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
-    return std::less<T*>()(a.get(), b.get());
+    return a._internal_less(b);
 }

-template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
 {
    a.swap(b);
 }

-template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::static_cast_tag());
 }

-template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::const_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::dynamic_cast_tag());
 }

-template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+// shared_*_cast names are deprecated. Use *_pointer_cast instead.
+
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::dynamic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
 {
    return shared_ptr<T>(r, detail::polymorphic_cast_tag());
 }

-template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
 {
    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
    return shared_static_cast<T>(r);
@@ -318,33 +409,59 @@ template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(share

 // get_pointer() enables boost::mem_fn to recognize shared_ptr

-template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 {
    return p.get();
 }

-// shared_from_this() creates a shared_ptr from a raw pointer (usually 'this')
+// operator<<

-namespace detail
-{
+#if defined(__GNUC__) &&  (__GNUC__ < 3)

-inline void sp_assert_counted_base(boost::counted_base const *)
+template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
 {
+    os << p.get();
+    return os;
 }

-template<class T> inline T * sp_remove_const(T const * p)
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# else
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# endif 
 {
-    return const_cast<T *>(p);
+    os << p.get();
+    return os;
 }

-} // namespace detail
+#endif

-template<class T> shared_ptr<T> shared_from_this(T * p)
+// get_deleter (experimental)
+
+#if (defined(__GNUC__) &&  (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
+
+// g++ 2.9x doesn't allow static_cast<X const *>(void *)
+// apparently EDG 2.38 also doesn't accept it
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
 {
-    detail::sp_assert_counted_base(p);
-    return shared_ptr<T>(detail::sp_remove_const(p));
+    void const * q = p._internal_get_deleter(typeid(D));
+    return const_cast<D *>(static_cast<D const *>(q));
 }

+#else
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+
+#endif
+
 } // namespace boost

 #ifdef BOOST_MSVC
--- a/include/boost/smart_ptr.hpp
+++ b/include/boost/smart_ptr.hpp
@@ -1,9 +1,25 @@
-//  Boost smart_ptr.hpp header file  -----------------------------------------//
+//
+//  smart_ptr.hpp
+//
+//  For convenience, this header includes the rest of the smart
+//  pointer library headers.
+//
+//  Copyright (c) 2003 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)
+//
+//  http://www.boost.org/libs/smart_ptr/smart_ptr.htm
+//

-// For compatibility, this header includes the header for the four "classic"
-// smart pointer class templates.
+#include <boost/config.hpp>

-#include <boost/scoped_ptr.hpp> 
+#include <boost/scoped_ptr.hpp>
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+# include <boost/weak_ptr.hpp>
+# include <boost/intrusive_ptr.hpp>
+# include <boost/enable_shared_from_this.hpp>
+#endif
--- a/include/boost/weak_ptr.hpp
+++ b/include/boost/weak_ptr.hpp
@@ -4,12 +4,11 @@
 //
 //  weak_ptr.hpp
 //
-//  Copyright (c) 2001, 2002 Peter Dimov
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
-//  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.
+// 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)
 //
 //  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
 //
@@ -24,7 +23,7 @@
 namespace boost
 {

-template<typename T> class weak_ptr
+template<class T> class weak_ptr
 {
 private:

@@ -35,33 +34,52 @@ public:

    typedef T element_type;

-    weak_ptr(): px(0), pn()
+    weak_ptr(): px(0), pn() // never throws in 1.30+
    {
    }

 //  generated copy constructor, assignment, destructor are fine

-    template<typename Y>
-    weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+
+//
+//  The "obvious" converting constructor implementation:
+//
+//  template<class Y>
+//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+//  {
+//  }
+//
+//  has a serious problem.
+//
+//  r.px may already have been invalidated. The px(r.px)
+//  conversion may require access to *r.px (virtual inheritance).
+//
+//  It is not possible to avoid spurious access violations since
+//  in multithreaded programs r.px may be invalidated at any point.
+//
+
+    template<class Y>
+    weak_ptr(weak_ptr<Y> const & r): pn(r.pn) // never throws
    {
+        px = r.lock().get();
    }

-    template<typename Y>
+    template<class Y>
    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
    {
    }

 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)

-    template<typename Y>
+    template<class Y>
    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
    {
-        px = r.px;
+        px = r.lock().get();
        pn = r.pn;
        return *this;
    }

-    template<typename Y>
+    template<class Y>
    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
@@ -71,14 +89,33 @@ public:

 #endif

-    void reset()
+    shared_ptr<T> lock() const // never throws
    {
-        this_type().swap(*this);
-    }
+#if defined(BOOST_HAS_THREADS)

-    T * get() const // never throws; deprecated, removal pending, don't use
-    {
-        return pn.use_count() == 0? 0: px;
+        // optimization: avoid throw overhead
+        if(expired())
+        {
+            return shared_ptr<element_type>();
+        }
+
+        try
+        {
+            return shared_ptr<element_type>(*this);
+        }
+        catch(bad_weak_ptr const &)
+        {
+            // Q: how can we get here?
+            // A: another thread may have invalidated r after the use_count test above.
+            return shared_ptr<element_type>();
+        }
+
+#else
+
+        // optimization: avoid try/catch overhead when single threaded
+        return expired()? shared_ptr<element_type>(): shared_ptr<element_type>(*this);
+
+#endif
    }

    long use_count() const // never throws
@@ -91,13 +128,24 @@ public:
        return pn.use_count() == 0;
    }

+    void reset() // never throws in 1.30+
+    {
+        this_type().swap(*this);
+    }
+
    void swap(this_type & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

-    bool less(this_type const & rhs) const // implementation detail, never throws
+    void _internal_assign(T * px2, detail::shared_count const & pn2)
+    {
+        px = px2;
+        pn = pn2;
+    }
+
+    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }
@@ -109,8 +157,8 @@ public:

 private:

-    template<typename Y> friend class weak_ptr;
-    template<typename Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+    template<class Y> friend class shared_ptr;

 #endif

@@ -119,30 +167,9 @@ private:

 };  // weak_ptr

-template<class T, class U> inline bool operator==(weak_ptr<T> const & a, weak_ptr<U> const & b)
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
-    return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<U> const & b)
-{
-    return a.get() != b.get();
-}
-
-#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
-
-// Resolve the ambiguity between our op!= and the one in rel_ops
-
-template<typename T> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<T> const & b)
-{
-    return a.get() != b.get();
-}
-
-#endif
-
-template<class T> inline bool operator<(weak_ptr<T> const & a, weak_ptr<T> const & b)
-{
-    return a.less(b);
+    return a._internal_less(b);
 }

 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
@@ -150,28 +177,12 @@ template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
    a.swap(b);
 }

-template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r) // never throws
+// deprecated, provided for backward compatibility
+template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r)
 {
-    // optimization: avoid throw overhead
-    if(r.use_count() == 0)
-    {
-        return shared_ptr<T>();
-    }
-
-    try
-    {
-        return shared_ptr<T>(r);
-    }
-    catch(use_count_is_zero const &)
-    {
-        return shared_ptr<T>();
-    }
+    return r.lock();
 }

-// Note: there is no get_pointer overload for weak_ptr.
-// This is intentional. Even get() will disappear in a
-// future release; these accessors are too error-prone.
-
 } // namespace boost

 #ifdef BOOST_MSVC
--- a/index.htm
+++ b/index.htm
@@ -1,47 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<title>Boost Smart Pointer Library</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<table border="1" bgcolor="#007F7F" cellpadding="2">
-  <tr>
-    <td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
-    <td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home</big></font></a></td>
-    <td><a href="../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries</big></font></a></td>
-    <td><a href="../../people/people.htm"><font face="Arial" color="#FFFFFF"><big>People</big></font></a></td>
-    <td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ</big></font></a></td>
-    <td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More</big></font></a></td>
-  </tr>
-</table>
-<h1>Smart Pointer Library</h1>
-<p>The smart pointer library includes five smart pointer class templates. Smart
-pointers ease the management of memory dynamically allocated with C++ <b>new</b>
-expressions. In addition, <b>scoped_ptr</b> can ease the management of memory
-dynamically allocated in other ways.</p>
-<ul>
-  <li><a href="smart_ptr.htm">Documentation</a> (HTML).</li>
-  <li>Header <a href="../../boost/scoped_ptr.hpp">scoped_ptr.hpp</a>.</li>
-  <li>Header <a href="../../boost/scoped_array.hpp">scoped_array.hpp</a>.</li>
-  <li>Header <a href="../../boost/shared_ptr.hpp">shared_ptr.hpp</a>.</li>
-  <li>Header <a href="../../boost/shared_array.hpp">shared_array.hpp</a>.</li>
-  <li>Header <a href="../../boost/weak_ptr.hpp">weak_ptr.hpp</a>.</li>
-  <li>Test program <a href="smart_ptr_test.cpp">smart_ptr_test.cpp</a>.</li>
-  <li>Originally submitted by
-  	<a href="../../people/greg_colvin.htm">Greg Colvin</a> and
-  	<a href="../../people/beman_dawes.html">Beman Dawes</a>,
-  	currently maintained by
-  	<a href="../../people/peter_dimov.htm">Peter Dimov</a> and
-  	<a href="../../people/darin_adler.htm">Darin Adler</a>.</li>
-</ul>
-
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->1 February 2002<!--webbot bot="Timestamp" endspan i-checksum="14885" -->.</p>
-
-</body>
-
-</html>
--- a/index.html
+++ b/index.html
@@ -0,0 +1,9 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=smart_ptr.htm">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="smart_ptr.htm">smart_ptr.htm</a>.
+</body>
+</html>
--- a/intrusive_ptr.html
+++ b/intrusive_ptr.html
@@ -0,0 +1,286 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+	<head>
+		<title>intrusive_ptr</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+	</head>
+	<body text="#000000" bgColor="#ffffff">
+		<h1><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle">intrusive_ptr 
+			class template</h1>
+		<p>
+			<A href="#Introduction">Introduction</A><br>
+			<A href="#Synopsis">Synopsis</A><br>
+			<A href="#Members">Members</A><br>
+			<A href="#functions">Free Functions</A><br>
+		</p>
+		<h2><a name="Introduction">Introduction</a></h2>
+		<p>The <b>intrusive_ptr</b> class template stores a pointer to an object with an 
+			embedded reference count. Every new <b>intrusive_ptr</b> instance increments 
+			the reference count by using an unqualified call to the function <STRONG>intrusive_ptr_add_ref</STRONG>, 
+			passing it the pointer as an argument. Similarly, when an <STRONG>intrusive_ptr</STRONG>
+			is destroyed, it calls <STRONG>intrusive_ptr_release</STRONG>; this function is 
+			responsible for destroying the object when its reference count drops to zero. 
+			The user is expected to provide suitable definitions of these two functions. On 
+			compilers that support argument-dependent lookup, <STRONG>intrusive_ptr_add_ref</STRONG>
+			and <STRONG>intrusive_ptr_release</STRONG> should be defined in the namespace 
+			that corresponds to their parameter; otherwise, the definitions need to go in 
+			namespace <STRONG>boost</STRONG>.</p>
+		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
+			to. <STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be implicitly converted to <STRONG>intrusive_ptr&lt;U&gt;</STRONG>
+			whenever <STRONG>T*</STRONG> can be implicitly converted to <STRONG>U*</STRONG>.</p>
+		<P>The main reasons to use <STRONG>intrusive_ptr</STRONG> are:</P>
+		<UL>
+			<LI>
+				Some existing frameworks or OSes provide objects with embedded reference 
+				counts;</LI>
+			<LI>
+				The memory footprint of <STRONG>intrusive_ptr</STRONG> is the same as the 
+				corresponding raw pointer;</LI>
+			<LI>
+				<STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be constructed from an arbitrary 
+				raw pointer of type <STRONG>T *</STRONG>.</LI></UL>
+		<P>As a general rule, if it isn't obvious whether <STRONG>intrusive_ptr</STRONG> better 
+			fits your needs than <STRONG>shared_ptr</STRONG>, try a <STRONG>shared_ptr</STRONG>-based 
+			design first.</P>
+		<h2><a name="Synopsis">Synopsis</a></h2>
+		<pre>namespace boost {
+
+  template&lt;class T&gt; class intrusive_ptr {
+
+    public:
+
+      typedef T <A href="#element_type" >element_type</A>;
+
+      <A href="#constructors" >intrusive_ptr</A>(); // never throws
+      <A href="#constructors" >intrusive_ptr</A>(T * p, bool add_ref = true);
+
+      <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr const &amp; r);
+      template&lt;class Y&gt; <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
+
+      <A href="#destructor" >~intrusive_ptr</A>();
+
+      intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr const &amp; r);
+      template&lt;class Y&gt; intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
+      template&lt;class Y&gt; intrusive_ptr &amp; <A href="#assignment" >operator=</A>(T * r);
+
+      T &amp; <A href="#indirection" >operator*</A>() const; // never throws
+      T * <A href="#indirection" >operator-&gt;</A>() const; // never throws
+      T * <A href="#get" >get</A>() const; // never throws
+
+      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
+
+      void <A href="#swap" >swap</A>(intrusive_ptr &amp; b); // never throws
+  };
+
+  template&lt;class T, class U&gt;
+    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+
+  template&lt;class T, class U&gt;
+    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+
+  template&lt;class T&gt;
+    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
+
+  template&lt;class T&gt;
+    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
+
+  template&lt;class T&gt;
+    bool <A href="#comparison" >operator==</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
+
+  template&lt;class T&gt;
+    bool <A href="#comparison" >operator!=</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
+
+  template&lt;class T, class U&gt;
+    bool <A href="#comparison" >operator&lt;</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+
+  template&lt;class T&gt; void <A href="#free-swap" >swap</A>(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws
+
+  template&lt;class T&gt; T * <A href="#get_pointer" >get_pointer</A>(intrusive_ptr&lt;T&gt; const &amp; p); // never throws
+
+  template&lt;class T, class U&gt;
+    intrusive_ptr&lt;T&gt; <A href="#static_pointer_cast" >static_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class T, class U&gt;
+    intrusive_ptr&lt;T&gt; <A href="#const_pointer_cast" >const_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class T, class U&gt;
+    intrusive_ptr&lt;T&gt; <A href="#dynamic_pointer_cast" >dynamic_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class E, class T, class Y&gt;
+    std::basic_ostream&lt;E, T&gt; &amp; <A href="#insertion-operator" >operator&lt;&lt;</A> (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);
+
+}</pre>
+		<h2><a name="Members">Members</a></h2>
+		<h3><a name="element_type">element_type</a></h3>
+		<pre>typedef T element_type;</pre>
+		<blockquote>
+			<p>Provides the type of the template parameter T.</p>
+		</blockquote>
+		<h3><a name="constructors">constructors</a></h3>
+		<pre>intrusive_ptr(); // never throws</pre>
+		<blockquote>
+			<p><b>Postconditions:</b> <code>get() == 0</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>intrusive_ptr(T * p, bool add_ref = true);</pre>
+		<blockquote>
+			<p><b>Effects:</b> <code>if(p != 0 &amp;&amp; add_ref) intrusive_ptr_add_ref(p);</code>.</p>
+			<p><b>Postconditions:</b> <code>get() == p</code>.</p>
+		</blockquote>
+		<pre>intrusive_ptr(intrusive_ptr const &amp; r); // never throws
+template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
+		<blockquote>
+			<p><b>Effects:</b> <code>if(r.get() != 0) intrusive_ptr_add_ref(r.get());</code>.</p>
+			<p><b>Postconditions:</b> <code>get() == r.get()</code>.</p>
+		</blockquote>
+		<h3><a name="destructor">destructor</a></h3>
+		<pre>~intrusive_ptr();</pre>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> <code>if(get() != 0) intrusive_ptr_release(get());</code>.</P>
+		</BLOCKQUOTE>
+		<H3><a name="assignment">assignment</a></H3>
+		<pre>intrusive_ptr &amp; operator=(intrusive_ptr const &amp; r); // never throws
+template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; const &amp; r); // never throws
+intrusive_ptr &amp; operator=(T * r);</pre>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>
+			<P><B>Returns:</B> <code>*this</code>.</P>
+		</BLOCKQUOTE>
+		<h3><a name="indirection">indirection</a></h3>
+		<pre>T &amp; operator*() const; // never throws</pre>
+		<blockquote>
+			<p><b>Requirements:</b> <code>get() != 0</code>.</p>
+			<p><b>Returns:</b> <code>*get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>T * operator-&gt;() const; // never throws</pre>
+		<blockquote>
+			<p><b>Requirements:</b> <code>get() != 0</code>.</p>
+			<p><b>Returns:</b> <code>get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<h3><a name="get">get</a></h3>
+		<pre>T * get() const; // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> the stored pointer.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<h3><a name="conversions">conversions</a></h3>
+		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, is 
+				equivalent to <code>get() != 0</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> This conversion operator allows <b>intrusive_ptr</b> objects to be 
+				used in boolean contexts, like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>. 
+				The actual target type is typically a pointer to a member function, avoiding 
+				many of the implicit conversion pitfalls.</P>
+		</blockquote>
+		<h3><a name="swap">swap</a></h3>
+		<pre>void swap(intrusive_ptr &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Effects:</b> Exchanges the contents of the two smart pointers.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<h2><a name="functions">Free Functions</a></h2>
+		<h3><a name="comparison">comparison</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T, class U&gt;
+  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T&gt;
+  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a.get() == b</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T&gt;
+  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a.get() != b</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T&gt;
+  bool operator==(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a == b.get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T&gt;
+  bool operator!=(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>a != b.get()</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>template&lt;class T, class U&gt;
+  bool operator&lt;(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>std::less&lt;T *&gt;()(a.get(), b.get())</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> Allows <STRONG>intrusive_ptr</STRONG> objects to be used as keys 
+				in associative containers.</P>
+		</blockquote>
+		<h3><a name="free-swap">swap</a></h3>
+		<pre>template&lt;class T&gt;
+  void swap(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws</pre>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+			<P><B>Notes:</B> Matches the interface of <B>std::swap</B>. Provided as an aid to 
+				generic programming.</P>
+		</BLOCKQUOTE>
+		<h3><a name="get_pointer">get_pointer</a></h3>
+		<pre>template&lt;class T&gt;
+  T * get_pointer(intrusive_ptr&lt;T&gt; const &amp; p); // never throws</pre>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>p.get()</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+			<P><B>Notes:</B> Provided as an aid to generic programming. Used by <A href="../bind/mem_fn.html">
+					mem_fn</A>.</P>
+		</BLOCKQUOTE>
+		<h3><a name="static_pointer_cast">static_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  intrusive_ptr&lt;T&gt; static_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
+		<h3><a name="const_pointer_cast">const_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  intrusive_ptr&lt;T&gt; const_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
+		<h3><a name="dynamic_pointer_cast">dynamic_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  intrusive_ptr&lt;T&gt; dynamic_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r);</pre>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
+		<h3><a name="insertion-operator">operator&lt;&lt;</a></h3>
+		<pre>template&lt;class E, class T, class Y&gt;
+    std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);</pre>
+		<BLOCKQUOTE>
+			<p><STRONG>Effects:</STRONG> <code>os &lt;&lt; p.get();</code>.</p>
+			<P><B>Returns:</B> <code>os</code>.</P>
+		</BLOCKQUOTE>
+		<hr>
+		<p>
+			$Date$</p>
+		<p>
+			<small>Copyright <20> 2003 Peter Dimov. 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.</small></p>
+	</body>
+</html>
--- a/scoped_array.htm
+++ b/scoped_array.htm
@@ -5,7 +5,7 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86"><a name="scoped_array">scoped_array</a>
+		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"><a name="scoped_array">scoped_array</a>
 			class template</h1>
 		<p>The <b>scoped_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated arrays are allocated with the C++ <b>new[]</b>
@@ -14,9 +14,10 @@
 		<p>The <b>scoped_array</b> template is a simple solution for simple needs. It 
 			supplies a basic "resource acquisition is initialization" facility, without 
 			shared-ownership or transfer-of-ownership semantics. Both its name and 
-			enforcement of semantics (by being <a href="../utility/utility.htm#class noncopyable">
-				noncopyable</a>) signal its intent to retain ownership solely within the 
-			current scope. Because it is <a href="../utility/utility.htm#class noncopyable">noncopyable</a>, 
+			enforcement of semantics (by being
+        <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>) signal its intent to retain ownership solely within the 
+			current scope. Because it is
+        <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
 			it is safer than <b>shared_array</b> for pointers which should not be copied.</p>
 		<p>Because <b>scoped_array</b> is so simple, in its usual implementation every 
 			operation is as fast as a built-in array pointer and it has no more space 
@@ -29,18 +30,18 @@
 			heavier duty but far more flexible. A <b>boost::array</b> is an alternative 
 			that does not use dynamic allocation.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {

-  template&lt;typename T&gt; class scoped_array : <a href="../utility/utility.htm#noncopyable">noncopyable</a> {
+  template&lt;class T&gt; class scoped_array : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {

    public:
      typedef T <a href="#element_type">element_type</a>;

      explicit <a href="#ctor">scoped_array</a>(T * p = 0); // never throws
-      <a href="#~scoped_array">~scoped_array</a>(); // never throws
+      <a href="#destructor">~scoped_array</a>(); // never throws

      void <a href="#reset">reset</a>(T * p = 0); // never throws

@@ -50,7 +51,7 @@
      void <a href="#swap">swap</a>(scoped_array &amp; b); // never throws
  };

-  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws
+  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws

 }</pre>
 		<h2>Members</h2>
@@ -62,23 +63,23 @@
 		<pre>explicit scoped_array(T * p = 0); // never throws</pre>
 		<p>Constructs a <b>scoped_array</b>, storing a copy of <b>p</b>, which must have 
 			been allocated via a C++ <b>new</b>[] expression or be 0. <b>T</b> is not 
-			required be a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">
+			required be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
-		<h3><a name="~scoped_array">destructor</a></h3>
+		<h3><a name="destructor">destructor</a></h3>
 		<pre>~scoped_array(); // never throws</pre>
 		<p>Deletes the array pointed to by the stored pointer. Note that <b>delete[]</b> on 
 			a pointer with a value of 0 is harmless. The guarantee that this does not throw 
 			exceptions depends on the requirement that the deleted array's objects' 
-			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
+			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(T * p = 0); // never throws</pre>
-		<p>If p is not equal to the stored pointer, deletes the array pointed to by the 
-			stored pointer and then stores a copy of p, which must have been allocated via 
-			a C++ <b>new[]</b> expression or be 0. The guarantee that this does not throw 
-			exceptions depends on the requirement that the deleted array's objects' 
-			destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
-				common requirements</a>.</p>
+		<p>
+			Deletes the array pointed to by the stored pointer and then stores a copy of p, 
+			which must have been allocated via a C++ <b>new[]</b> expression or be 0. The 
+			guarantee that this does not throw exceptions depends on the requirement that 
+			the deleted array's objects' destructors do not throw exceptions. See the smart 
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="operator[]">subscripting</a></h3>
 		<pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
 		<p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
@@ -88,24 +89,23 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(scoped_array &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;typename T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws</pre>
+		<pre>template&lt;class T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
-		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan--> 
-			1 February 2002<!--webbot bot="Timestamp" endspan i-checksum="13964"--></p>
+		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan-->09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310"--></p>
 		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			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>
 	</body>
-</html>
+</html>
--- a/scoped_ptr.htm
+++ b/scoped_ptr.htm
@@ -5,7 +5,7 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86"><a name="scoped_ptr">scoped_ptr</a>
+		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"><a name="scoped_ptr">scoped_ptr</a>
 			class template</h1>
 		<p>The <b>scoped_ptr</b> class template stores a pointer to a dynamically allocated 
 			object. (Dynamically allocated objects are allocated with the C++ <b>new</b> expression.) 
@@ -14,9 +14,9 @@
 		<p>The <b>scoped_ptr</b> template is a simple solution for simple needs. It 
 			supplies a basic "resource acquisition is initialization" facility, without 
 			shared-ownership or transfer-of-ownership semantics. Both its name and 
-			enforcement of semantics (by being <a href="../utility/utility.htm#class noncopyable">
+			enforcement of semantics (by being <a href="../utility/utility.htm#Class_noncopyable">
 				noncopyable</a>) signal its intent to retain ownership solely within the 
-			current scope. Because it is <a href="../utility/utility.htm#class noncopyable">noncopyable</a>, 
+			current scope. Because it is <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
 			it is safer than <b>shared_ptr</b> or <b>std::auto_ptr</b> for pointers which 
 			should not be copied.</p>
 		<p>Because <b>scoped_ptr</b> is simple, in its usual implementation every operation 
@@ -29,12 +29,12 @@
 			allocated array. See <a href="scoped_array.htm"><b>scoped_array</b></a> for 
 			that usage.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {

-  template&lt;typename T&gt; class scoped_ptr : <a href="../utility/utility.htm#class noncopyable">noncopyable</a> {
+  template&lt;class T&gt; class scoped_ptr : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {

   public:
     typedef T <a href="#element_type">element_type</a>;
@@ -51,7 +51,7 @@
     void <a href="#swap">swap</a>(scoped_ptr &amp; b); // never throws
  };

-  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws
+  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws

 }</pre>
 		<h2>Members</h2>
@@ -62,7 +62,7 @@
 		<pre>explicit scoped_ptr(T * p = 0); // never throws</pre>
 		<p>Constructs a <b>scoped_ptr</b>, storing a copy of <b>p</b>, which must have been 
 			allocated via a C++ <b>new</b> expression or be 0. <b>T</b> is not required be 
-			a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
+			a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
 				requirements</a>.</p>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~scoped_ptr(); // never throws</pre>
@@ -71,15 +71,15 @@
 		<P>
 			The guarantee that this does not throw exceptions depends on the requirement 
 			that the deleted object's destructor does not throw exceptions. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</P>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</P>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(T * p = 0); // never throws</pre>
-		<p>If p is not equal to the stored pointer, deletes the object pointed to by the 
-			stored pointer and then stores a copy of p, which must have been allocated via 
-			a C++ <b>new</b> expression or be 0. The guarantee that this does not throw 
-			exceptions depends on the requirement that the deleted object's destructor does 
-			not throw exceptions. See the smart pointer <a href="smart_ptr.htm#Common requirements">
-				common requirements</a>.</p>
+		<p>
+			Deletes the object pointed to by the stored pointer and then stores a copy of 
+			p, which must have been allocated via a C++ <b>new</b> expression or be 0. The 
+			guarantee that this does not throw exceptions depends on the requirement that 
+			the deleted object's destructor does not throw exceptions. See the smart 
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="indirection">indirection</a></h3>
 		<pre>T &amp; operator*() const; // never throws</pre>
 		<p>Returns a reference to the object pointed to by the stored pointer. Behavior is 
@@ -89,15 +89,15 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(scoped_ptr &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;typename T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws</pre>
+		<pre>template&lt;class T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<h2><a name="example">Example</a></h2>
@@ -115,7 +115,7 @@ class MyClass {
    int add_one() { return ++*ptr; }
 };

-void main()
+int main()
 {
    boost::scoped_ptr&lt;Shoe&gt; x(new Shoe);
    MyClass my_instance;
@@ -150,12 +150,12 @@ Buckle my shoe</pre>
 		<p>One common usage of <b>scoped_ptr</b> is to implement a handle/body (also called 
 			pimpl) idiom which avoids exposing the body (implementation) in the header 
 			file.</p>
-		<p>The <a href="scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a> sample 
-			program includes a header file, <a href="scoped_ptr_example.hpp">scoped_ptr_example.hpp</a>, 
+		<p>The <a href="example/scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a> sample 
+			program includes a header file, <a href="example/scoped_ptr_example.hpp">scoped_ptr_example.hpp</a>, 
 			which uses a <b>scoped_ptr&lt;&gt;</b> to an incomplete type to hide the 
 			implementation. The instantiation of member functions which require a complete 
-			type occurs in the <a href="scoped_ptr_example.cpp">scoped_ptr_example.cpp</a> implementation 
-			file.</p>
+			type occurs in the <a href="example/scoped_ptr_example.cpp">scoped_ptr_example.cpp</a>
+			implementation file.</p>
 		<h2>Frequently Asked Questions</h2>
 		<p><b>Q</b>. Why doesn't <b>scoped_ptr</b> have a release() member?<br>
 			<b>A</b>. When reading source code, it is valuable to be able to draw 
@@ -166,7 +166,7 @@ Buckle my shoe</pre>
 			is required. (supplied by Dave Abrahams)</p>
 		<hr>
 		<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->
-			17 September 2002<!--webbot bot="Timestamp" endspan i-checksum="15110" --></p>
+			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
 		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Copyright 2002 Peter Dimov. Permission to copy, use, modify, sell and 
 			distribute this document is granted provided this copyright notice appears in 
--- a/scoped_ptr_example_test.cpp
+++ b/scoped_ptr_example_test.cpp
@@ -1,10 +0,0 @@
-// Boost scoped_ptr_example_test main program  -------------------------------//
-
-#include "scoped_ptr_example.hpp"
-
-int main()
-{
-  example my_example;
-  my_example.do_something();
-  return 0;
-}
--- a/shared_array.htm
+++ b/shared_array.htm
@@ -5,7 +5,7 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">shared_array 
+		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86">shared_array 
 			class template</h1>
 		<p>The <b>shared_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated array are allocated with the C++ <b>new[]</b>
@@ -26,18 +26,18 @@
 		<p>A <b>shared_ptr</b> to a <b>std::vector</b> is an alternative to a <b>shared_array</b>
 			that is a bit heavier duty but far more flexible.</p>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
+			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
 		<h2>Synopsis</h2>
 		<pre>namespace boost {

-  template&lt;typename T&gt; class shared_array {
+  template&lt;class T&gt; class shared_array {

    public:
      typedef T <a href="#element_type">element_type</a>;

      explicit <a href="#constructors">shared_array</a>(T * p = 0);
-      template&lt;typename D&gt; <a href="#constructors">shared_array</a>(T * p, D d);
+      template&lt;class D&gt; <a href="#constructors">shared_array</a>(T * p, D d);
      <a href="#destructor">~shared_array</a>(); // never throws

      <a href="#constructors">shared_array</a>(shared_array const &amp; r); // never throws
@@ -45,7 +45,7 @@
      shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws

      void <a href="#reset">reset</a>(T * p = 0);
-      template&lt;typename D&gt; void <a href="#reset">reset</a>(T * p, D d);
+      template&lt;class D&gt; void <a href="#reset">reset</a>(T * p, D d);

      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const() const; // never throws
      T * <a href="#get">get</a>() const; // never throws
@@ -56,14 +56,14 @@
      void <a href="#swap">swap</a>(shared_array&lt;T&gt; &amp; b); // never throws
  };

-  template&lt;typename T&gt;
+  template&lt;class T&gt;
    bool <a href="#comparison">operator==</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;typename T&gt;
+  template&lt;class T&gt;
    bool <a href="#comparison">operator!=</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;typename T&gt;
+  template&lt;class T&gt;
    bool <a href="#comparison">operator&lt;</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws

-  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b); // never throws
+  template&lt;class T&gt; void <a href="#free-swap">swap</a>(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b); // never throws

 }</pre>
 		<h2>Members</h2>
@@ -78,7 +78,7 @@
 				~shared_array</a>). The only exception which may be thrown by this 
 			constructor is <b>std::bad_alloc</b>. If an exception is thrown, <b>delete[] p</b>
 			is called.</p>
-		<pre>template&lt;typename D&gt; shared_array(T * p, D d);</pre>
+		<pre>template&lt;class D&gt; shared_array(T * p, D d);</pre>
 		<p>Constructs a <b>shared_array</b>, storing a copy of <b>p</b> and of <b>d</b>. 
 			Afterwards, the <a href="#use_count">use count</a> is 1. <b>D</b>'s copy 
 			constructor and destructor must not throw. When the the time comes to delete 
@@ -97,9 +97,9 @@
 			a pointer with a value of 0 is harmless. <b>T</b> need not be a complete type. 
 			The guarantee that this does not throw exceptions depends on the requirement 
 			that the deleted object's destructor does not throw exceptions. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
-		<h3><a name="operator=">assignment</a></h3>
-		<pre>shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws</pre>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
+		<h3><a name="assignment">assignment</a></h3>
+		<pre>shared_array &amp; operator=(shared_array const &amp; r); // never throws</pre>
 		<p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object.</p>
@@ -109,13 +109,13 @@
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object. The only exception which may be thrown is <b>std::bad_alloc</b>. 
 			If an exception is thrown, <b>delete[] p</b> is called.</p>
-		<pre>template&lt;typename D&gt; void reset(T * p, D d);</pre>
+		<pre>template&lt;class D&gt; void reset(T * p, D d);</pre>
 		<p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
 			then replaces this <b>shared_array</b> with the new one, destroying the 
 			replaced object. <b>D</b>'s copy constructor must not throw. The only exception 
 			which may be thrown is <b>std::bad_alloc</b>. If an exception is thrown, <b>d(p)</b>
 			is called.</p>
-		<h3><a name="indirection">indexing</a></h3>
+		<h3><a name="indexing">indexing</a></h3>
 		<pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
 		<p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
 			pointer. Behavior is undefined and almost certainly undesirable if the stored 
@@ -124,16 +124,16 @@
 		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
 		<p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="unique">unique</a></h3>
 		<pre>bool unique() const; // never throws</pre>
 		<p>Returns true if no other <b>shared_array</b> is sharing ownership of the stored 
 			pointer, false otherwise. <b>T</b> need not be a complete type. See the smart 
-			pointer <a href="smart_ptr.htm#Common requirements">common requirements</a>.</p>
+			pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
 		<h3><a name="use_count">use_count</a></h3>
 		<pre>long use_count() const; // never throws</pre>
 		<p>Returns the number of <b>shared_array</b> objects sharing ownership of the 
-			stored pointer. <b>T</b> need not be a complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">
+			stored pointer. <b>T</b> need not be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
 				common requirements</a>.</p>
 		<p>Because <b>use_count</b> is not necessarily efficient to implement for 
 			implementations of <b>shared_array</b> that do not use an explicit reference 
@@ -142,18 +142,18 @@
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(shared_ptr &amp; b); // never throws</pre>
 		<p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
 				requirements</a>.</p>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
-		<pre>template&lt;typename T&gt;
+		<pre>template&lt;class T&gt;
  bool operator==(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;typename T&gt;
+template&lt;class T&gt;
  bool operator!=(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;typename T&gt;
+template&lt;class T&gt;
  bool operator&lt;(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws</pre>
 		<p>Compares the stored pointers of the two smart pointers. <b>T</b> need not be a 
-			complete type. See the smart pointer <a href="smart_ptr.htm#Common requirements">common 
+			complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
 				requirements</a>.</p>
 		<p>The <b>operator&lt;</b> overload is provided to define an ordering so that <b>shared_array</b>
 			objects can be used in associative containers such as <b>std::map</b>. The 
@@ -163,13 +163,14 @@ template&lt;typename T&gt;
 			paragraph 2) but <b>std::less&lt;&gt;</b> on pointers is well-defined (20.3.3 
 			[lib.comparisons] paragraph 8).</p>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;typename T&gt;
+		<pre>template&lt;class T&gt;
  void swap(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b) // never throws</pre>
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
-		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->
-			8 February 2002<!--webbot bot="Timestamp" i-checksum="38439" endspan --></p>
+		<p>Revised 
+			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan --> 
+			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
 		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Permission to copy, use, modify, sell and distribute this document is granted 
 			provided this copyright notice appears in all copies. This document is provided 
--- a/shared_ptr.htm
+++ b/shared_ptr.htm
@@ -5,18 +5,19 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body text="#000000" bgColor="#ffffff">
-		<h1><IMG height="86" alt="c++boost.gif (8819 bytes)" src="../../c++boost.gif" width="277" align="middle">shared_ptr 
+		<h1><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle">shared_ptr 
 			class template</h1>
 		<p><A href="#Introduction">Introduction</A><br>
-			<a href="#BestPractices">Best Practices</a><br>
+			<A href="#BestPractices">Best Practices</A><br>
 			<A href="#Synopsis">Synopsis</A><br>
 			<A href="#Members">Members</A><br>
 			<A href="#functions">Free Functions</A><br>
 			<A href="#example">Example</A><br>
 			<A href="#Handle/Body">Handle/Body Idiom</A><br>
-			<a href="#ThreadSafety">Thread Safety</a><br>
+			<A href="#ThreadSafety">Thread Safety</A><br>
 			<A href="#FAQ">Frequently Asked Questions</A><br>
-			<A href="smarttests.htm">Smart Pointer Timings</A></p>
+			<A href="smarttests.htm">Smart Pointer Timings</A><br>
+			<A href="sp_techniques.html">Programming Techniques</A></p>
 		<h2><a name="Introduction">Introduction</a></h2>
 		<p>The <b>shared_ptr</b> class template stores a pointer to a dynamically allocated 
 			object, typically with a C++ <EM>new-expression</EM> . The object pointed to is 
@@ -47,21 +48,20 @@
 			where <STRONG>U</STRONG> is an accessible base of <STRONG>T</STRONG>, and to <STRONG>
 				shared_ptr&lt;void&gt;</STRONG>.</P>
 		<h2><a name="BestPractices">Best Practices</a></h2>
-		<P>A simple guideline that nearly eliminates&nbsp;the possibility of memory leaks 
-			is: always use a named smart pointer variable to hold the result of <STRONG>new. </STRONG>
+		<P>A simple guideline that nearly eliminates the possibility of memory leaks is: 
+			always use a named smart pointer variable to hold the result of <STRONG>new. </STRONG>
 			Every occurence of the <STRONG>new</STRONG> keyword in the code should have the 
 			form:</P>
 		<PRE>shared_ptr&lt;T&gt; p(new Y);</PRE>
 		<P>It is, of course, acceptable to use another smart pointer in place of <STRONG>shared_ptr</STRONG>
 			above; having <STRONG>T</STRONG> and <STRONG>Y</STRONG> be the same type, or 
-			passing arguments to <STRONG>Y</STRONG>'s constructor&nbsp;is also OK.</P>
+			passing arguments to <STRONG>Y</STRONG>'s constructor is also OK.</P>
 		<P>If you observe this guideline, it naturally follows that you will have no 
 			explicit <STRONG>delete</STRONG>s; <STRONG>try/catch</STRONG> constructs will 
 			be rare.</P>
 		<P>Avoid using unnamed <STRONG>shared_ptr</STRONG> temporaries to save typing; to 
 			see why this is dangerous, consider this example:</P>
-		<PRE>
-void f(shared_ptr&lt;int&gt;, int);
+		<PRE>void f(shared_ptr&lt;int&gt;, int);
 int g();

 void ok()
@@ -81,38 +81,38 @@ void bad()
 			evaluated in unspecified order, it is possible for <STRONG>new int(2)</STRONG> to 
 			be evaluated first, <STRONG>g()</STRONG> second, and we may never get to the <STRONG>
 				shared_ptr </STRONG>constructor if <STRONG>g</STRONG> throws an exception. 
-			See <A href="http://www.gotw.ca/gotw/056.htm">Herb Sutter's treatment</A> of 
-			the issue for more information.</P>
+			See <A href="http://www.gotw.ca/gotw/056.htm">Herb Sutter's treatment</A> (also <A href="http://www.cuj.com/reference/articles/2002/0212/0212_sutter.htm">
+				here</A>) of the issue for more information.</P>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {

-  class use_count_is_zero: public std::exception;
+  class bad_weak_ptr: public std::exception;

-  template&lt;typename T&gt; class <A href="weak_ptr.htm" >weak_ptr</A>;
+  template&lt;class T&gt; class <A href="weak_ptr.htm" >weak_ptr</A>;

-  template&lt;typename T&gt; class shared_ptr {
+  template&lt;class T&gt; class shared_ptr {

    public:

      typedef T <A href="#element_type" >element_type</A>;

-      <A href="#constructors" >shared_ptr</A>();
-      template&lt;typename Y&gt; explicit <A href="#constructors" >shared_ptr</A>(Y * p);
-      template&lt;typename Y, typename D&gt; <A href="#constructors" >shared_ptr</A>(Y * p, D d);
+      <A href="#constructors" >shared_ptr</A>(); // never throws
+      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(Y * p);
+      template&lt;class Y, class D&gt; <A href="#constructors" >shared_ptr</A>(Y * p, D d);
      <A href="#destructor" >~shared_ptr</A>(); // never throws

      <A href="#constructors" >shared_ptr</A>(shared_ptr const &amp; r); // never throws
-      template&lt;typename Y&gt; <A href="#constructors" >shared_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-      explicit <A href="#constructors" >shared_ptr</A>(<A href="weak_ptr.htm" >weak_ptr</A> const &amp; r);
-      template&lt;typename Y&gt; <A href="#constructors" >shared_ptr</A>(std::auto_ptr&lt;Y&gt; &amp; r);
+      template&lt;class Y&gt; <A href="#constructors" >shared_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);
+      template&lt;class Y&gt; explicit <A href="#constructors" >shared_ptr</A>(std::auto_ptr&lt;Y&gt; &amp; r);

      shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr const &amp; r); // never throws  
-      template&lt;typename Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-      template&lt;typename Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(std::auto_ptr&lt;Y&gt; &amp; r);
+      template&lt;class Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+      template&lt;class Y&gt; shared_ptr &amp; <A href="#assignment" >operator=</A>(std::auto_ptr&lt;Y&gt; &amp; r);

-      void <A href="#reset" >reset</A> ();
-      template&lt;typename Y&gt; void <A href="#reset" >reset</A> (Y * p);
-      template&lt;typename Y&gt; template&lt;typename D&gt; void <A href="#reset" >reset</A>(Y * p, D d);
+      void <A href="#reset" >reset</A>(); // never throws
+      template&lt;class Y&gt; void <A href="#reset" >reset</A>(Y * p);
+      template&lt;class Y, class D&gt; void <A href="#reset" >reset</A>(Y * p, D d);

      T &amp; <A href="#indirection" >operator*</A>() const; // never throws
      T * <A href="#indirection" >operator-&gt;</A>() const; // never throws
@@ -121,38 +121,45 @@ void bad()
      bool <A href="#unique" >unique</A>() const; // never throws
      long <A href="#use_count" >use_count</A>() const; // never throws

-      operator <a href="#conversions"><i>unspecified-bool-type</i></a> () const; // never throws
+      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws

-      void <A href="#swap" >swap</A>(shared_ptr&lt;T&gt; &amp; b); // never throws
+      void <A href="#swap" >swap</A>(shared_ptr &amp; b); // never throws
  };

-  template&lt;typename T, typename U&gt;
+  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator==</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-  template&lt;typename T, typename U&gt;
+
+  template&lt;class T, class U&gt;
    bool <A href="#comparison" >operator!=</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-  template&lt;typename T&gt;
-    bool <A href="#comparison" >operator&lt;</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;T&gt; const &amp; b); // never throws

-  template&lt;typename T&gt; void <A href="#free-swap" >swap</A>(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws
+  template&lt;class T, class U&gt;
+    bool <A href="#comparison" >operator&lt;</A>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws

-  template&lt;typename T&gt; T * <A href="#get_pointer" >get_pointer</A>(shared_ptr&lt;T&gt; const &amp; p); // never throws
+  template&lt;class T&gt; void <A href="#free-swap" >swap</A>(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws

-  template&lt;typename T, typename U&gt;
-    shared_ptr&lt;T&gt; <A href="#shared_static_cast" >shared_static_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
-  template&lt;typename T, typename U&gt;
-    shared_ptr&lt;T&gt; <A href="#shared_dynamic_cast" >shared_dynamic_cast</A>(shared_ptr&lt;U&gt; const &amp; r);
-  template&lt;typename T, typename U&gt;
-    shared_ptr&lt;T&gt; <A href="#shared_polymorphic_cast" >shared_polymorphic_cast</A>(shared_ptr&lt;U&gt; const &amp; r);
-  template&lt;typename T, typename U&gt;
-    shared_ptr&lt;T&gt; <A href="#shared_polymorphic_downcast" >shared_polymorphic_downcast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
+  template&lt;class T&gt; T * <A href="#get_pointer" >get_pointer</A>(shared_ptr&lt;T&gt; const &amp; p); // never throws

+  template&lt;class T, class U&gt;
+    shared_ptr&lt;T&gt; <A href="#static_pointer_cast" >static_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class T, class U&gt;
+    shared_ptr&lt;T&gt; <A href="#const_pointer_cast" >const_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class T, class U&gt;
+    shared_ptr&lt;T&gt; <A href="#dynamic_pointer_cast" >dynamic_pointer_cast</A>(shared_ptr&lt;U&gt; const &amp; r); // never throws
+
+  template&lt;class E, class T, class Y&gt;
+    std::basic_ostream&lt;E, T&gt; &amp; <A href="#insertion-operator" >operator&lt;&lt;</A> (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);
+
+  template&lt;class D, class T&gt;
+    D * <A href="#get_deleter">get_deleter</A>(shared_ptr&lt;T&gt; const &amp; p);
 }</pre>
-		<P><EM>[It might be&nbsp;convenient to relax the requirements on <STRONG>shared_ptr</STRONG>'s 
+		<P><EM>[It might be convenient to relax the requirements on <STRONG>shared_ptr</STRONG>'s 
 				signature, allowing an additional, defaulted, template parameter; the parameter 
 				can encode the threading model, for example. This would help in detecting 
 				possible ODR violations.</EM></P>
-		<P><EM> On the other hand, using <STRONG>shared_ptr</STRONG> as an argument to 
-				a&nbsp;template template parameter requires an exact signature match. </EM><EM>Metaprogramming 
+		<P><EM>On the other hand, using <STRONG>shared_ptr</STRONG> as an argument to a 
+				template template parameter requires an exact signature match. </EM><EM>Metaprogramming 
 				experts tend to deemphasize template template parameters as they are too 
 				inflexible, but the alternative is typically an std::allocator::rebind-type 
 				"hack".]</EM></P>
@@ -163,40 +170,36 @@ void bad()
 			<p>Provides the type of the template parameter T.</p>
 		</blockquote>
 		<h3><a name="constructors">constructors</a></h3>
-		<pre>shared_ptr();</pre>
+		<pre>shared_ptr(); // never throws</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1; the stored 
-				pointer is 0.</p>
-			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
-			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
-				effect.</p>
+			<p><b>Effects:</b> Constructs an <EM>empty</EM> <b>shared_ptr</b>. <EM>Empty</EM> <STRONG>
+					shared_ptr</STRONG> objects have an unspecified <A href="#use_count">use_count</A>.</p>
+			<p><b>Postconditions:</b> <code>get() == 0</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<P><EM>[The poscondition of use_count() == 1 is too strong. Having the nothrow 
-				guarantee is important, since <STRONG>reset()</STRONG> is specified in terms of 
-				the default constructor, but the current specification requires that a count be 
-				allocated. Therefore, this postcondition will be dropped in a future release. 
-				The use count of a default-constructed <STRONG>shared_ptr</STRONG>, including 
-				all copies created from it, will probably be left unspecified.</EM></P>
-		<P><EM>There are two possible nothrow implementations, one stores 0 as a pointer to the 
+		<P><EM>[The nothrow guarantee is important, since <STRONG>reset()</STRONG> is specified 
+				in terms of the default constructor; this implies that the constructor must not 
+				allocate memory.</EM></P>
+		<P><EM>There are two possible implementations, one stores 0 as a pointer to the 
 				reference count, the other uses a single statically allocated count for all 
 				default-constructed <STRONG>shared_ptr</STRONG>s. The second option is 
 				difficult to achieve in the current header-only reference implementation due to 
 				thread safety issues and initialization order, but it should not be precluded 
-				by the specification.</EM></P>
+				by the specification. That's why the use_count() has been left unspecified.</EM></P>
 		<P><EM>A future release may enable <STRONG>shared_ptr</STRONG> construction from a 
 				literal zero, for consistency with built-in pointers. It is not clear yet 
 				whether this constructor should be left implicit, enabling <STRONG>0</STRONG> to 
 				be used as a shorthand for <STRONG>shared_ptr&lt;T&gt;().</STRONG>]</EM></P>
-		<pre>template&lt;typename Y&gt; explicit shared_ptr(Y * p);</pre>
+		<pre>template&lt;class Y&gt; explicit shared_ptr(Y * p);</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <b>p</b> must be convertible to <b>T *</b>. <STRONG>Y</STRONG>
 				must be a complete type. The expression <code>delete p</code> must be 
 				well-formed, must not invoke undefined behavior, and must not throw exceptions.
 			</p>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, storing a copy of <b>p</b>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1.</p>
-			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <b>p</b>.</p>
+			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>delete p</code> is 
 				called.</p>
 			<P><STRONG>Notes:</STRONG> <B>p</B> must be a pointer to an object that was 
@@ -208,38 +211,23 @@ void bad()
 				pointer type passed. The destructor will call <STRONG>delete</STRONG> with the 
 				same pointer, complete with its original type, even when <STRONG>T</STRONG> does 
 				not have a virtual destructor, or is <STRONG>void</STRONG>.</EM></P>
-		<P><EM>In the current implementation, if <STRONG>p</STRONG> is convertible to <STRONG>counted_base 
-					*</STRONG>, <STRONG>shared_ptr</STRONG> will use the embedded reference 
-				count supplied by <STRONG>counted_base</STRONG>. This is an (experimental) 
-				attempt to provide a way for <STRONG>shared_ptr</STRONG> to be constructed from 
-				a raw pointer such as <STRONG>this</STRONG>. A free function <STRONG>shared_from_this(q)</STRONG>
-				performs the conversion when <STRONG>q</STRONG> is convertible to <STRONG>counted_base 
-					const *</STRONG>.</EM></P>
-		<P><EM>The optional intrusive counting employed by the current implementation allows <STRONG>
-					shared_ptr</STRONG> to interoperate with <STRONG>intrusive_ptr</STRONG>, an 
-				experimental generic intrusive-counted smart pointer.</EM></P>
-		<P><EM> Another possible implementation is to use a global pointer-to-count map instead 
-				of intrusive counting. <STRONG>shared_from_this</STRONG> would no longer be 
-				O(1), which is a concern for some users, although I do not expect any 
-				performance problems, since the operation is rare. Maintaining a global 
-				map&nbsp;is difficult; it needs to be initialized before any <STRONG>shared_ptr</STRONG>
-				instances are constructed, and the initialization needs to be&nbsp;thread safe. 
-				In addition, under the Windows dynamic library model, it is possible for 
-				several maps to exist.</EM></P>
-		<P><EM> It is not yet clear which implementation should be used, or whether the 
-				specification should allow both; nevertheless,&nbsp;the ability to make a <STRONG>shared_ptr</STRONG>
-				from <STRONG>this</STRONG> is considered essential&nbsp;by experienced smart 
-				pointer users.</EM><EM>]</EM></P>
-		<pre>template&lt;typename Y, typename D&gt; shared_ptr(Y * p, D d);</pre>
+		<P><EM>The optional intrusive counting support has been dropped as it exposes too much 
+				implementation details and doesn't interact well with <STRONG>weak_ptr</STRONG>. 
+				The current implementation uses a different mechanism, <A href="enable_shared_from_this.html">
+					enable_shared_from_this</A>, to solve the "<STRONG>shared_ptr</STRONG> from <STRONG>
+					this</STRONG>" problem.</EM><EM>]</EM></P>
+		<pre>template&lt;class Y, class D&gt; shared_ptr(Y * p, D d);</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <B>p</B> must be convertible to <B>T *</B>. <STRONG>D</STRONG>
 				must be <STRONG>CopyConstructible</STRONG>. The copy constructor and destructor 
 				of <b>D</b> must not throw. The expression <code>d(p)</code> must be 
 				well-formed, must not invoke undefined behavior, and must not throw exceptions.
 			</p>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, storing a copy of <b>p</b> and <b>d</b>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 1.</p>
-			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
+			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <STRONG>
+					p</STRONG> and the deleter <b>d</b>.</p>
+			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>d(p)</code> is called.</p>
 			<p><b>Notes:</b> When the the time comes to delete the object pointed to by <b>p</b>, 
 				the stored copy of <STRONG>d</STRONG> is invoked with the stored copy of <STRONG>p</STRONG>
@@ -250,76 +238,87 @@ void bad()
 				is not part of the type, changing the allocation strategy does not break source 
 				or binary compatibility, and does not require a client recompilation. For 
 				example, a "no-op" deallocator is useful when returning a <STRONG>shared_ptr</STRONG>
-				to a statically allocated object.</EM></P>
+				to a statically allocated object, and other variations allow a <STRONG>shared_ptr</STRONG>
+				to be used as a wrapper for another smart pointer, easing interoperability.</EM></P>
 		<P><EM>The support for custom deallocators does not impose significant overhead. Other <STRONG>
 					shared_ptr</STRONG> features still require a deallocator to be kept.</EM></P>
-		<P><EM>The requirement that the copy constructor of <b>D</b> does not throw is too 
-				strong. It will be removed when some core language issues are resolved 
-				(cv-qualified function types, partial ordering clarifications.)]</EM></P>
+		<P><EM>The requirement that the copy constructor of <b>D</b> does not throw comes from 
+				the pass by value. If the copy constructor throws, the pointer is leaked. 
+				Removing the requirement requires a pass by (const) reference.</EM></P>
+		<P><EM>Pass by reference is problematic since (1) pass by value conveniently changes 
+				functions (function references) to function pointers (this has to be performed 
+				manually otherwise and some compilers may not be able to do it) and (2) const 
+				references don't currently (per the standard) bind to functions. This can be 
+				solved (I think) but it requires an overload set that breaks on many compilers 
+				due to 14.5.5.2 problems (and of course it will break on compilers that don't 
+				do partial ordering at all.)</EM></P>
+		<P><EM>The main problem with pass by reference, though, lies in its interaction with 
+				rvalues. A const reference may still cause a copy, and will require a const 
+				operator(). A non-const reference won't bind to an rvalue at all. A good 
+				solution to this problem is the rvalue reference proposed in <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">
+					N1377</A>/<A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">N1385</A>.]</EM></P>
 		<pre>shared_ptr(shared_ptr const &amp; r); // never throws
-template&lt;typename Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
+template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, as if by storing a copy of the 
-				pointer stored in <STRONG>r</STRONG>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> for all copies is 
-				increased by one.</p>
+			<p><b>Effects:</b> If <b>r</b> is <EM>empty</EM>, constructs an <EM>empty</EM> <b>shared_ptr</b>; 
+				otherwise, constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with <b>r</b>.</p>
+			<p><b>Postconditions:</b> <code>get() == r.get() &amp;&amp; use_count() == 
+					r.use_count()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<P><EM>[The postcondition will be relaxed when a default-constructed <STRONG>shared_ptr</STRONG>
-				is being copied.]</EM></P>
-		<pre>explicit shared_ptr(<A href="weak_ptr.htm" >weak_ptr</A> const &amp; r);</pre>
+		<pre>template&lt;class Y&gt; explicit shared_ptr(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b>, as if by storing a copy of the 
-				pointer stored in <STRONG>r</STRONG>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> for all copies is 
-				increased by one.</p>
-			<p><b>Throws:</b> <b>use_count_is_zero</b> when <code>r.use_count() == 0</code>.</p>
+			<p><b>Effects:</b> If <b>r</b> is <EM>empty</EM>, constructs an <EM>empty</EM> <b>shared_ptr</b>; 
+				otherwise, constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with <b>r</b>
+				and stores a copy of the pointer stored in <STRONG>r</STRONG>.</p>
+			<p><b>Postconditions:</b> <code>use_count() == r.use_count()</code>.</p>
+			<p><b>Throws:</b> <b>bad_weak_ptr</b> when <code>r.use_count() == 0</code>.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
 				effect.</p>
 		</blockquote>
-		<P><EM>[This constructor is an optional part of the specification; it depends on the 
-				existence of <STRONG>weak_ptr</STRONG>. It is true that <STRONG>weak_ptr</STRONG>
-				support imposes overhead on every <STRONG>shared_ptr</STRONG> user, regardless 
-				of whether weak pointers are used.</EM></P>
-		<P><EM>On the other hand, cyclic references are a serious problem with all reference 
-				counted designs. Not providing a solution within the library is unacceptable; 
-				if users are forced to reinvent the weak pointer wheel, there is substantial 
-				probability that they will get it wrong, as designing a safe <STRONG>weak_ptr</STRONG>
-				interface is non-trivial.</EM></P>
-		<P><EM>My opinion is that the added functionality is worth the cost. <STRONG>weak_ptr</STRONG>
-				is provided in the reference implementation as a proof of concept.]</EM></P>
-		<pre>template&lt;typename Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
+		<pre>template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Constructs a <B>shared_ptr</B>, as if by storing a copy of <STRONG>r.release()</STRONG>.</P>
-			<P><B>Postconditions:</B> <A href="#use_count">use count</A> is 1.</P>
-			<P><B>Throws:</B> <B>std::bad_alloc</B>.</P>
+			<p><b>Postconditions:</b> <code>use_count() == 1</code>.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<P><B>Exception safety:</B> If an exception is thrown, the constructor has no 
 				effect.</P>
 		</BLOCKQUOTE>
 		<P><EM>[This constructor takes a the source <STRONG>auto_ptr</STRONG> by reference and 
 				not by value, and cannot accept <STRONG>auto_ptr</STRONG> temporaries. This is 
-				by design, as the constructor offers the strong guarantee.]</EM></P>
+				by design, as the constructor offers the strong guarantee; an rvalue reference 
+				would solve this problem, too.]</EM></P>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~shared_ptr(); // never throws</pre>
 		<BLOCKQUOTE>
-			<P><B>Effects:</B> If <STRONG>*this</STRONG> is the sole owner (<code>use_count() == 1</code>), 
-				destroys the object pointed to by the stored pointer.</P>
-			<P><B>Postconditions:</B> <A href="#use_count">use count</A> for all remaining 
-				copies is decreased by one.</P>
+			<P><B>Effects:</B></P>
+			<UL>
+				<LI>
+					If <STRONG>*this</STRONG> is <EM>empty</EM>, or <EM>shares ownership</EM> with 
+					another <STRONG>shared_ptr</STRONG> instance (<code>use_count() &gt; 1</code>), 
+				there are no side effects.
+				<LI>
+					Otherwise, if <STRONG>*this</STRONG> <EM>owns</EM> a pointer <STRONG>p</STRONG> 
+					and a deleter <STRONG>d</STRONG>, <code>d(p)</code>
+				is called.
+				<LI>
+					Otherwise, <STRONG>*this</STRONG> <EM>owns</EM> a pointer <STRONG>p</STRONG>, 
+					and <code>delete p</code> is called.</LI></UL>
 			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<H3><a name="assignment">assignment</a></H3>
 		<pre>shared_ptr &amp; operator=(shared_ptr const &amp; r); // never throws
-template&lt;typename Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-template&lt;typename Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
+template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(r).swap(*this)</code>.</P>
+			<P><B>Returns:</B> <code>*this</code>.</P>
 			<P><B>Notes:</B> The use count updates caused by the temporary object construction 
 				and destruction are not considered observable side effects, and the 
 				implementation is free to meet the effects (and the implied guarantees) via 
 				different means, without creating a temporary. In particular, in the example:</P>
-			<pre>
-shared_ptr&lt;int&gt; p(new int);
+			<pre>shared_ptr&lt;int&gt; p(new int);
 shared_ptr&lt;void&gt; q(p);
 p = p;
 q = p;
@@ -327,23 +326,21 @@ q = p;
 			<p>both assignments may be no-ops.</p>
 		</BLOCKQUOTE>
 		<P><EM>[Some experts consider the note to be redundant, as it appears to essentially 
-				mirror the "as if" rile. However, experience suggests that when C++ code is 
+				mirror the "as if" rule. However, experience suggests that when C++ code is 
 				used to describe effects, it is often misinterpreted as required 
 				implementation. In addition, it is not entirely clear whether the "as if" rule 
 				actually applies here, so it's better to be explicit about the possible 
 				optimizations.]</EM></P>
 		<h3><a name="reset">reset</a></h3>
-		<pre>void reset();</pre>
+		<pre>void reset(); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr().swap(*this)</code>.</P>
 		</BLOCKQUOTE>
-		<P><EM>[<STRONG>reset()</STRONG> will offer the nothrow guarantee in a future 
-				implementation.]</EM></P>
-		<pre>template&lt;typename Y&gt; void reset(Y * p);</pre>
+		<pre>template&lt;class Y&gt; void reset(Y * p);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
-		<pre>template&lt;typename Y, typename D&gt; void reset(Y * p, D d);</pre>
+		<pre>template&lt;class Y, class D&gt; void reset(Y * p, D d);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p, d).swap(*this)</code>.</P>
 		</BLOCKQUOTE>
@@ -375,13 +372,12 @@ q = p;
 				If you are using <code>unique()</code> to implement copy on write, do not rely 
 				on a specific value when the stored pointer is zero.</P>
 		</blockquote>
-		<P><EM>[In a future release, <STRONG>unique()</STRONG> will return an unspecified value 
-				for a default-constructed <STRONG>shared_ptr.</STRONG>]</EM></P>
 		<h3><a name="use_count">use_count</a></h3>
 		<pre>long use_count() const; // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects sharing ownership of the 
-				stored pointer.</p>
+			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects, <STRONG>*this</STRONG> included, 
+				that <i>share ownership</i> with <b>*this</b>, or an unspecified nonnegative 
+				value when <STRONG>*this</STRONG> is <EM>empty</EM>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
 				for debugging and testing purposes, not for production code.</P>
@@ -389,8 +385,8 @@ q = p;
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> an&nbsp;unspecified value that, when used in boolean contexts, 
-				is equivalent to <code>get() != 0</code>.</p>
+			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, is 
+				equivalent to <code>get() != 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> This conversion operator allows <b>shared_ptr</b> objects to be 
 				used in boolean contexts, like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>. 
@@ -398,8 +394,8 @@ q = p;
 				many of the implicit conversion pitfalls.</P>
 		</blockquote>
 		<P><EM>[The conversion to bool is not merely syntactic sugar. It allows <STRONG>shared_ptr</STRONG>s 
-				to be declared in conditions when using <STRONG>shared_dynamic_cast </STRONG>or <STRONG>
-					make_shared</STRONG>.]</EM></P>
+				to be declared in conditions when using <A href="#dynamic_pointer_cast">dynamic_pointer_cast</A>
+				or <A href="weak_ptr.htm#lock">weak_ptr::lock</A>.]</EM></P>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(shared_ptr &amp; b); // never throws</pre>
 		<blockquote>
@@ -408,24 +404,30 @@ q = p;
 		</blockquote>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
+		<pre>template&lt;class T, class U&gt;
  bool operator==(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<pre>template&lt;typename T, typename U&gt;
+		<pre>template&lt;class T, class U&gt;
  bool operator!=(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-		<pre>template&lt;typename T&gt;
-  bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;T&gt; const &amp; b); // never throws</pre>
+		<pre>template&lt;class T, class U&gt;
+  bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
 		<blockquote>
-			<p><b>Returns:</b> an&nbsp;unspecified value such that <b>operator&lt;</b> is a 
-				strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
-				of the C++ standard.</p>
+			<p><b>Returns:</b> an unspecified value such that</p>
+			<UL>
+				<LI>
+					<b>operator&lt;</b> is a strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
+				of the C++ standard;
+				<LI>
+					under the equivalence relation defined by <STRONG>operator&lt;</STRONG>, <code>!(a 
+						&lt; b) &amp;&amp; !(b &lt; a)</code>, two <STRONG>shared_ptr</STRONG> instances 
+					are equivalent if and only if they <EM>share ownership</EM>.</LI></UL>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>shared_ptr</STRONG> objects to be used as keys in 
 				associative containers.</P>
@@ -436,10 +438,10 @@ q = p;
 				standard algorithms use <STRONG>operator&lt;</STRONG> instead of <STRONG>std::less</STRONG>
 				for comparisons when a predicate is not supplied. Composite objects, like <STRONG>std::pair</STRONG>, 
 				also implement their <STRONG>operator&lt;</STRONG> in terms of their contained 
-				subobjects'&nbsp;<STRONG>operator&lt;</STRONG>.</EM></P>
+				subobjects' <STRONG>operator&lt;</STRONG>.</EM></P>
 		<P><EM>The rest of the comparison operators are omitted by design.]</EM></P>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;typename T&gt;
+		<pre>template&lt;class T&gt;
  void swap(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
@@ -451,7 +453,7 @@ q = p;
 				as this is currently the only legal way to supply a <STRONG>swap</STRONG> function 
 				that has a chance to be used by the standard library.]</EM></P>
 		<h3><a name="get_pointer">get_pointer</a></h3>
-		<pre>template&lt;typename T&gt;
+		<pre>template&lt;class T&gt;
  T * get_pointer(shared_ptr&lt;T&gt; const &amp; p); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><B>Returns:</B> <code>p.get()</code>.</P>
@@ -459,23 +461,39 @@ q = p;
 			<P><B>Notes:</B> Provided as an aid to generic programming. Used by <A href="../bind/mem_fn.html">
 					mem_fn</A>.</P>
 		</BLOCKQUOTE>
-		<h3><a name="shared_static_cast">shared_static_cast</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; shared_static_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+		<h3><a name="static_pointer_cast">static_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
 		<BLOCKQUOTE>
 			<P><STRONG>Requires:</STRONG> The expression <code>static_cast&lt;T*&gt;(r.get())</code>
 				must be well-formed.</P>
-			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
-				of <code>static_cast&lt;T*&gt;(r.get())</code> and shares ownership with <b>r</b>.</P>
+			<P><B>Returns:</B> If <b>r</b> is <i>empty</i>, an <i>empty</i> <b>shared_ptr&lt;T&gt;</b>; 
+				otherwise, a <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy of <code>
+					static_cast&lt;T*&gt;(r.get())</code> and <i>shares ownership</i> with <b>r</b>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> the seemingly equivalent expression</P>
 			<p><code>shared_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code></p>
 			<p>will eventually result in undefined behavior, attempting to delete the same 
 				object twice.</p>
 		</BLOCKQUOTE>
-		<h3><a name="shared_dynamic_cast">shared_dynamic_cast</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; shared_dynamic_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
+		<h3><a name="const_pointer_cast">const_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+		<BLOCKQUOTE>
+			<P><STRONG>Requires:</STRONG> The expression <code>const_cast&lt;T*&gt;(r.get())</code>
+				must be well-formed.</P>
+			<P><B>Returns:</B> If <b>r</b> is <i>empty</i>, an <i>empty</i> <b>shared_ptr&lt;T&gt;</b>; 
+				otherwise, a <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy of <code>
+					const_cast&lt;T*&gt;(r.get())</code> and <i>shares ownership</i> with <b>r</b>.</P>
+			<P><B>Throws:</B> nothing.</P>
+			<P><B>Notes:</B> the seemingly equivalent expression</P>
+			<p><code>shared_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code></p>
+			<p>will eventually result in undefined behavior, attempting to delete the same 
+				object twice.</p>
+		</BLOCKQUOTE>
+		<h3><a name="dynamic_pointer_cast">dynamic_pointer_cast</a></h3>
+		<pre>template&lt;class T, class U&gt;
+  shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><STRONG>Requires:</STRONG> The expression <CODE>dynamic_cast&lt;T*&gt;(r.get())</CODE>
 				must be well-formed and its behavior defined.</P>
@@ -483,47 +501,35 @@ q = p;
 			<UL>
 				<LI>
 					When <CODE>dynamic_cast&lt;T*&gt;(r.get())</CODE> returns a nonzero value, a <STRONG>
-						shared_ptr&lt;T&gt;</STRONG> object that stores a copy of it and shares 
-					ownership with <STRONG>r</STRONG>;
+						shared_ptr&lt;T&gt;</STRONG> object that stores a copy of it and <i>shares 
+						ownership</i> with <STRONG>r</STRONG>;
 				<LI>
-					Otherwise, a default-constructed <STRONG>shared_ptr&lt;T&gt;</STRONG> object.</LI></UL>
-			<P><B>Throws:</B> <STRONG>std::bad_alloc</STRONG>.</P>
-			<P><B>Exception safety:</B> If an exception is thrown, the function has no effect.</P>
+					Otherwise, an <i>empty</i> <STRONG>shared_ptr&lt;T&gt;</STRONG> object.</LI></UL>
+			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> the seemingly equivalent expression</P>
 			<P><CODE>shared_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</CODE></P>
 			<P>will eventually result in undefined behavior, attempting to delete the same 
 				object twice.</P>
 		</BLOCKQUOTE>
-		<h3><a name="shared_polymorphic_cast">shared_polymorphic_cast</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; shared_polymorphic_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
+		<h3><a name="insertion-operator">operator&lt;&lt;</a></h3>
+		<pre>template&lt;class E, class T, class Y&gt;
+    std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);</pre>
 		<BLOCKQUOTE>
-			<p><STRONG>Requires:</STRONG> The expression <CODE><A href="../conversion/cast.htm#Polymorphic_cast">
-						polymorphic_cast</A>&lt;T*&gt;(r.get())</CODE> must be well-formed and 
-				its behavior defined.</p>
-			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
-				of <CODE><A href="../conversion/cast.htm#Polymorphic_cast">polymorphic_cast</A>&lt;T*&gt;(r.get())</CODE>
-				and shares ownership with <B>r</B>.</P>
-			<P><B>Throws:</B> <STRONG>std::bad_cast</STRONG> when the pointer cannot be 
-				converted.</P>
-			<P><B>Exception safety:</B> If an exception is thrown, the function has no effect.</P>
+			<p><STRONG>Effects:</STRONG> <code>os &lt;&lt; p.get();</code>.</p>
+			<P><B>Returns:</B> <b>os</b>.</P>
 		</BLOCKQUOTE>
-		<h3><a name="shared_polymorphic_downcast">shared_polymorphic_downcast</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
-  shared_ptr&lt;T&gt; shared_polymorphic_downcast(shared_ptr&lt;U&gt; const &amp; r); // never throws</pre>
+		<h3><a name="get_deleter">get_deleter</a></h3>
+		<pre>template&lt;class D, class T&gt;
+    D * get_deleter(shared_ptr&lt;T&gt; const &amp; p);</pre>
 		<BLOCKQUOTE>
-			<p><STRONG>Requires:</STRONG> The expression <CODE><A href="../conversion/cast.htm#Polymorphic_cast">
-						polymorphic_downcast</A>&lt;T*&gt;(r.get())</CODE> must be well-formed 
-				and its behavior defined.</p>
-			<P><B>Returns:</B> A <STRONG>shared_ptr&lt;T&gt;</STRONG> object that stores a copy 
-				of <CODE><A href="../conversion/cast.htm#Polymorphic_cast">polymorphic_downcast</A>&lt;T*&gt;(r.get())</CODE>
-				and shares ownership with <B>r</B>.</P>
-			<P><B>Throws:</B> nothing.</P>
+			<P><B>Returns:</B> If <STRONG>*this</STRONG> <EM>owns</EM> a deleter <STRONG>d</STRONG>
+				of type (cv-unqualified) <STRONG>D</STRONG>, returns <code>&amp;d</code>; 
+				otherwise returns 0.</P>
 		</BLOCKQUOTE>
 		<h2><a name="example">Example</a></h2>
-		<p>See <A href="shared_ptr_example.cpp">shared_ptr_example.cpp</A> for a complete 
-			example program. The program builds a <b>std::vector</b> and <b>std::set</b> of <b>shared_ptr</b>
-			objects.</p>
+		<p>See <A href="example/shared_ptr_example.cpp">shared_ptr_example.cpp</A> for a 
+			complete example program. The program builds a <b>std::vector</b> and <b>std::set</b>
+			of <b>shared_ptr</b> objects.</p>
 		<p>Note that after the containers have been populated, some of the <b>shared_ptr</b>
 			objects will have a use count of 1 rather than a use count of 2, since the set 
 			is a <b>std::set</b> rather than a <b>std::multiset</b>, and thus does not 
@@ -536,26 +542,25 @@ q = p;
 		<p>One common usage of <b>shared_ptr</b> is to implement a handle/body (also called 
 			pimpl) idiom which avoids exposing the body (implementation) in the header 
 			file.</p>
-		<p>The <A href="shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</A> sample 
-			program includes a header file, <A href="shared_ptr_example2.hpp">shared_ptr_example2.hpp</A>, 
+		<p>The <A href="example/shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</A>
+			sample program includes a header file, <A href="example/shared_ptr_example2.hpp">shared_ptr_example2.hpp</A>, 
 			which uses a <b>shared_ptr&lt;&gt;</b> to an incomplete type to hide the 
 			implementation. The instantiation of member functions which require a complete 
-			type occurs in the <A href="shared_ptr_example2.cpp">shared_ptr_example2.cpp</A>
+			type occurs in the <A href="example/shared_ptr_example2.cpp">shared_ptr_example2.cpp</A>
 			implementation file. Note that there is no need for an explicit destructor. 
 			Unlike ~scoped_ptr, ~shared_ptr does not require that <b>T</b> be a complete 
 			type.</p>
 		<h2><a name="ThreadSafety">Thread Safety</a></h2>
 		<p><STRONG>shared_ptr</STRONG> objects offer the same level of thread safety as 
-			built-in types.&nbsp;A&nbsp;<STRONG>shared_ptr</STRONG> instance can be "read" 
-			(accessed using only const operations)&nbsp;simultaneously by multiple threads. 
-			Different <STRONG>shared_ptr</STRONG> instances can be "written to" (accessed 
-			using mutable operations such as <STRONG>operator= </STRONG>or <STRONG>reset</STRONG>) 
-			simultaneosly by multiple threads (even when these instances are copies, and 
-			share the same reference count underneath.)</p>
+			built-in types. A <STRONG>shared_ptr</STRONG> instance can be "read" (accessed 
+			using only const operations) simultaneously by multiple threads. Different <STRONG>shared_ptr</STRONG>
+			instances can be "written to" (accessed using mutable operations such as <STRONG>operator=
+			</STRONG>or <STRONG>reset</STRONG>) simultaneosly by multiple threads (even 
+			when these instances are copies, and share the same reference count 
+			underneath.)</p>
 		<P>Any other simultaneous accesses result in undefined behavior.</P>
 		<P>Examples:</P>
-		<pre>
-shared_ptr&lt;int&gt; p(new int(42));
+		<pre>shared_ptr&lt;int&gt; p(new int(42));

 //--- Example 1 ---

@@ -568,7 +573,6 @@ shared_ptr&lt;int&gt; p3(p); // OK, multiple reads are safe
 //--- Example 2 ---

 // thread A
-
 p.reset(new int(1912)); // writes p

 // thread B
@@ -607,45 +611,60 @@ p3.reset(new int(2)); // undefined, multiple writes
 		<P><B>Q.</B> There are several variations of shared pointers, with different 
 			tradeoffs; why does the smart pointer library supply only a single 
 			implementation? It would be useful to be able to experiment with each type so 
-			as to find the most suitable for the job at hand?<BR>
+			as to find the most suitable for the job at hand?</P>
+		<P>
 			<b>A.</b> An important goal of <STRONG>shared_ptr</STRONG> is to provide a 
 			standard shared-ownership pointer. Having a single pointer type is important 
 			for stable library interfaces, since different shared pointers typically cannot 
 			interoperate, i.e. a reference counted pointer (used by library A) cannot share 
-			ownership with a linked pointer (used by library B.)</P>
+			ownership with a linked pointer (used by library B.)<BR>
+		</P>
 		<P><B>Q.</B> Why doesn't <B>shared_ptr</B> have template parameters supplying 
-			traits or policies to allow extensive user customization?<BR>
+			traits or policies to allow extensive user customization?</P>
+		<P>
 			<B>A.</B> Parameterization discourages users. The <B>shared_ptr</B> template is 
 			carefully crafted to meet common needs without extensive parameterization. Some 
 			day a highly configurable smart pointer may be invented that is also very easy 
 			to use and very hard to misuse. Until then, <B>shared_ptr</B> is the smart 
 			pointer of choice for a wide range of applications. (Those interested in policy 
 			based smart pointers should read <A href="http://cseng.aw.com/book/0,,0201704315,00.html">
-				Modern C++ Design</A> by Andrei Alexandrescu.)</P>
+				Modern C++ Design</A> by Andrei Alexandrescu.)<BR>
+		</P>
 		<P><B>Q.</B> I am not convinced. Default parameters can be used where appropriate 
-			to hide the complexity. Again, why not policies?<BR>
+			to hide the complexity. Again, why not policies?</P>
+		<P>
 			<B>A.</B> Template parameters affect the type. See the answer to the first 
-			question above.</P>
-		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> use a linked list implementation?<br>
+			question above.<BR>
+		</P>
+		<P><B>Q.</B> Why doesn't <b>shared_ptr</b> use a linked list implementation?</P>
+		<P>
 			<b>A.</b> A linked list implementation does not offer enough advantages to 
 			offset the added cost of an extra pointer. See <A href="smarttests.htm">timings</A>
 			page. In addition, it is expensive to make a linked list implementation thread 
-			safe.</p>
-		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> (or any of the other Boost smart 
-			pointers) supply an automatic conversion to <b>T*</b>?<br>
-			<b>A.</b> Automatic conversion is believed to be too error prone.</p>
-		<p><b>Q.</b> Why does <b>shared_ptr</b> supply use_count()?<br>
+			safe.<BR>
+		</P>
+		<P><b>Q.</b> Why doesn't <b>shared_ptr</b> (or any of the other Boost smart 
+			pointers) supply an automatic conversion to <b>T*</b>?</P>
+		<P>
+			<b>A.</b> Automatic conversion is believed to be too error prone.<BR>
+		</P>
+		<P><B>Q.</B> Why does <b>shared_ptr</b> supply use_count()?</P>
+		<P>
 			<b>A.</b> As an aid to writing test cases and debugging displays. One of the 
 			progenitors had use_count(), and it was useful in tracking down bugs in a 
-			complex project that turned out to have cyclic-dependencies.</p>
-		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> specify complexity requirements?<br>
+			complex project that turned out to have cyclic-dependencies.<BR>
+		</P>
+		<P><B>Q.</B> Why doesn't <b>shared_ptr</b> specify complexity requirements?</P>
+		<P>
 			<b>A.</b> Because complexity requirements limit implementors and complicate the 
 			specification without apparent benefit to <b>shared_ptr</b> users. For example, 
 			error-checking implementations might become non-conforming if they had to meet 
-			stringent complexity requirements.</p>
-		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> provide a release() function?<br>
+			stringent complexity requirements.<BR>
+		</P>
+		<P><b>Q.</b> Why doesn't <b>shared_ptr</b> provide a release() function?</P>
+		<P>
 			<b>A.</b> <b>shared_ptr</b> cannot give away ownership unless it's unique() 
-			because the other copy will still destroy the object.</p>
+			because the other copy will still destroy the object.</P>
 		<p>Consider:</p>
 		<blockquote><pre>shared_ptr&lt;int&gt; a(new int);
 shared_ptr&lt;int&gt; b(a); // a.use_count() == b.use_count() == 2
@@ -654,17 +673,27 @@ int * p = a.release();

 // Who owns p now? b will still call delete on it in its destructor.</pre>
 		</blockquote>
-		<p><b>Q.</b> Why doesn't <b>shared_ptr</b> provide (your pet feature here)?<br>
-			<b>A.</b> Because (your pet feature here) would mandate a reference counted 
-			implementation or a linked list implementation, or some other specific 
-			implementation. This is not the intent.</p>
+		<p>Furthermore, the pointer returned by <code>release()</code> would be difficult 
+			to deallocate reliably, as the source <b>shared_ptr</b> could have been created 
+			with a custom deleter.<BR>
+		</p>
+		<P><b>Q.</b> Why is <code>operator-&gt;()</code> const, but its return value is a 
+			non-const pointer to the element type?</P>
+		<P>
+			<b>A.</b> Shallow copy pointers, including raw pointers, typically don't 
+			propagate constness. It makes little sense for them to do so, as you can always 
+			obtain a non-const pointer from a const one and then proceed to modify the 
+			object through it.<b>shared_ptr</b> is "as close to raw pointers as possible 
+			but no closer".<BR>
+			<BR>
+		</P>
 		<hr>
-		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->
-			23 July 2002<!--webbot bot="Timestamp" i-checksum="38439" endspan --></p>
-		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-			Copyright 2002 Peter Dimov. 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>
+			$Date$</p>
+		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
+				Copyright 2002, 2003 Peter Dimov. 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.</small></p>
 	</body>
 </html>
--- a/smart_ptr.htm
+++ b/smart_ptr.htm
@@ -5,8 +5,15 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="#ffffff" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">Smart 
+		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86">Smart 
 			Pointers</h1>
+		<p><a href="#Introduction">Introduction</a><br>
+			<a href="#common_requirements">Common Requirements</a><br>
+			<a href="#Exception_Safety">Exception Safety</a><br>
+			<a href="#Exception-specifications">Exception-specifications</a><br>
+			<a href="#History">History and Acknowledgements</a><br>
+			<a href="#References">References</a></p>
+		<h2><a name="Introduction">Introduction</a></h2>
 		<p>Smart pointers are objects which store pointers to dynamically allocated (heap) 
 			objects. They behave much like built-in C++ pointers except that they 
 			automatically delete the object pointed to at the appropriate time. Smart 
@@ -17,7 +24,7 @@
 			responsible for deletion of the object when it is no longer needed.</p>
 		<p>The smart pointer library provides five smart pointer class templates:</p>
 		<div align="left">
-			<table border="1" cellpadding="4" cellspacing="4">
+			<table border="1" cellpadding="4" cellspacing="0">
 				<tr>
 					<td><a href="scoped_ptr.htm"><b>scoped_ptr</b></a></td>
 					<td><a href="../../boost/scoped_ptr.hpp">&lt;boost/scoped_ptr.hpp&gt;</a></td>
@@ -43,20 +50,27 @@
 					<td><a href="../../boost/weak_ptr.hpp">&lt;boost/weak_ptr.hpp&gt;</a></td>
 					<td>Non-owning observers of an object owned by <b>shared_ptr</b>.</td>
 				</tr>
+				<tr>
+					<td><a href="intrusive_ptr.html"><b>intrusive_ptr</b></a></td>
+					<td><a href="../../boost/intrusive_ptr.hpp">&lt;boost/intrusive_ptr.hpp&gt;</a></td>
+					<td>Shared ownership of objects with an embedded reference count.</td>
+				</tr>
 			</table>
 		</div>
 		<p>These templates are designed to complement the <b>std::auto_ptr</b> template.</p>
 		<p>They are examples of the "resource acquisition is initialization" idiom 
 			described in Bjarne Stroustrup's "The C++ Programming Language", 3rd edition, 
 			Section 14.4, Resource Management.</p>
-		<p>A test program, <a href="smart_ptr_test.cpp">smart_ptr_test.cpp</a>, is provided 
-			to verify correct operation.</p>
+		<p>A test program, <a href="test/smart_ptr_test.cpp">smart_ptr_test.cpp</a>, is 
+			provided to verify correct operation.</p>
 		<p>A page on <a href="compatibility.htm">compatibility</a> with older versions of 
 			the Boost smart pointer library describes some of the changes since earlier 
 			versions of the smart pointer implementation.</p>
 		<p>A page on <a href="smarttests.htm">smart pointer timings</a> will be of interest 
 			to those curious about performance issues.</p>
-		<h2><a name="Common requirements">Common Requirements</a></h2>
+		<P>A page on <A href="sp_techniques.html">smart pointer programming techniques</A> lists 
+			some advanced applications of <code>shared_ptr</code> and <code>weak_ptr</code>.</P>
+		<h2><a name="common_requirements">Common Requirements</a></h2>
 		<p>These smart pointer class templates have a template parameter, <b>T</b>, which 
 			specifies the type of the object pointed to by the smart pointer. The behavior 
 			of the smart pointer templates is undefined if the destructor or <b>operator delete</b>
@@ -79,7 +93,7 @@
 			these idioms.</p>
 		<p>Note that <b>scoped_ptr</b> requires that <b>T</b> be a complete type at 
 			destruction time, but <b>shared_ptr</b> does not.</p>
-		<h2>Exception Safety</h2>
+		<h2><a name="Exception_Safety">Exception Safety</a></h2>
 		<p>Several functions in these smart pointer classes are specified as having "no 
 			effect" or "no effect except such-and-such" if an exception is thrown. This 
 			means that when an exception is thrown by an object of one of these classes, 
@@ -87,10 +101,10 @@
 			which resulted in the exception being thrown. This amounts to a guarantee that 
 			there are no detectable side effects. Other functions never throw exceptions. 
 			The only exception ever thrown by functions which do throw (assuming <b>T</b> meets 
-			the <a href="#Common requirements">common requirements</a>) is <b>std::bad_alloc</b>, 
+			the <a href="#common_requirements">common requirements</a>) is <b>std::bad_alloc</b>, 
 			and that is thrown only by functions which are explicitly documented as 
 			possibly throwing <b>std::bad_alloc</b>.</p>
-		<h2>Exception-specifications</h2>
+		<h2><a name="Exception-specifications">Exception-specifications</a></h2>
 		<p>Exception-specifications are not used; see <a href="../../more/lib_guide.htm#Exception-specification">
 				exception-specification rationale</a>.</p>
 		<p>All the smart pointer templates contain member functions which can never throw 
@@ -99,8 +113,8 @@
 				// never throws</code>.
 		</p>
 		<p>Functions which destroy objects of the pointed to type are prohibited from 
-			throwing exceptions by the <a href="#Common requirements">common requirements</a>.</p>
-		<h2>History and Acknowledgements</h2>
+			throwing exceptions by the <a href="#common_requirements">common requirements</a>.</p>
+		<h2><a name="History">History</a> and Acknowledgements</h2>
 		<p>January 2002. Peter Dimov reworked all four classes, adding features, fixing 
 			bugs, and splitting them into four separate headers, and added <b>weak_ptr</b>. 
 			See the <a href="compatibility.htm">compatibility</a> page for a summary of the 
@@ -114,17 +128,10 @@
 		<p>September 1999. Luis Coelho provided <b>shared_ptr::swap</b> and <b>shared_array::swap</b></p>
 		<p>May 1999. In April and May, 1999, Valentin Bonnard and David Abrahams made a 
 			number of suggestions resulting in numerous improvements.</p>
-		<p>October 1998. In 1994 Greg Colvin proposed to the C++ Standards Committee 
-			classes named <b>auto_ptr</b> and <b>counted_ptr</b> which were very similar to 
-			what we now call <b>scoped_ptr</b> and <b>shared_ptr</b>. The committee 
-			document was 94-168/N0555, Exception Safe Smart Pointers. In one of the very 
-			few cases where the Library Working Group's recommendations were not followed 
-			by the full committee, <b>counted_ptr</b> was rejected and surprising 
-			transfer-of-ownership semantics were added to <b>auto_ptr</b>.</p>
-		<p>Beman Dawes proposed reviving the original semantics under the names <b>safe_ptr</b>
-			and <b>counted_ptr</b> at an October, 1998, meeting of Per Andersson, Matt 
+		<p>October 1998. Beman Dawes proposed reviving the original semantics under the 
+			names <b>safe_ptr</b> and <b>counted_ptr</b>, meeting of Per Andersson, Matt 
 			Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis, Dietmar K<>hl, 
-			Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four 
+			Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four new 
 			class names were finalized, it was decided that there was no need to exactly 
 			follow the <b>std::auto_ptr</b> interface, and various function signatures and 
 			semantics were finalized.</p>
@@ -154,11 +161,22 @@
 			experimented with.</p>
 		<p>But Greg Colvin and Jerry Schwarz argued that "parameterization will discourage 
 			users", and in the end we choose to supply only the direct implementation.</p>
+		<p>Summer, 1994. Greg Colvin proposed to the C++ Standards Committee classes named <b>auto_ptr</b>
+			and <b>counted_ptr</b> which were very similar to what we now call <b>scoped_ptr</b>
+			and <b>shared_ptr</b>. <a href="#Col-94">[Col-94]</a> In one of the very few 
+			cases where the Library Working Group's recommendations were not followed by 
+			the full committee, <b>counted_ptr</b> was rejected and surprising 
+			transfer-of-ownership semantics were added to <b>auto_ptr</b>.</p>
+		<h2><a name="References">References</a></h2>
+		<p>[<a name="Col-94">Col-94</a>] Gregory Colvin, <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/1994/N0555.pdf">
+				Exception Safe Smart Pointers</a>, C++ committee document 94-168/N0555, 
+			July, 1994.</p>
+		<p>[<a name="E&amp;D-94">E&amp;D-94</a>] John R. Ellis &amp; David L. Detlefs, <a href="http://www.usenix.org/publications/library/proceedings/c++94/full_papers/ellis.a">
+				Safe, Efficient Garbage Collection for C++</a>, Usenix Proceedings, 
+			February, 1994. This paper includes an extensive discussion of weak pointers 
+			and an extensive bibliography.</p>
 		<hr>
-		<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan
--> 
-			4 February 2002<!--webbot bot="Timestamp" endspan i-checksum="40737"
--></p>
+		<p>$Date$</p>
 		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Permission to copy, use, modify, sell and distribute this document is granted 
 			provided this copyright notice appears in all copies. This document is provided 
--- a/smarttests.htm
+++ b/smarttests.htm
@@ -9,7 +9,7 @@

 <body bgcolor="#FFFFFF">

-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" WIDTH="277" HEIGHT="86">Smart Pointer Timings</h1>
+<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" WIDTH="277" HEIGHT="86">Smart Pointer Timings</h1>

 <p>In late January 2000, Mark Borgerding put forward a suggestion to boost for 
  a new design of smart pointer whereby an intrusive doubly linked list is used 
--- a/sp_techniques.html
+++ b/sp_techniques.html
@@ -0,0 +1,760 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+	<head>
+		<title>Smart Pointer Programming Techniques</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+	</head>
+	<body text="#000000" bgColor="#ffffff">
+		<h1><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle">Smart 
+			Pointer Programming Techniques</h1>
+		<p><A href="#incomplete">Using incomplete classes for implementation hiding</A><br>
+			<A href="#pimpl">The "Pimpl" idiom</A><br>
+			<A href="#abstract">Using abstract classes for implementation hiding</A><br>
+			<A href="#preventing_delete">Preventing <code>delete px.get()</code></A><br>
+			<A href="#array">Using a <code>shared_ptr</code> to hold a pointer to an array</A><br>
+			<A href="#encapsulation">Encapsulating allocation details, wrapping factory 
+				functions</A><br>
+			<A href="#static">Using a <code>shared_ptr</code> to hold a pointer to a statically 
+				allocated object</A><br>
+			<A href="#com">Using a <code>shared_ptr</code> to hold a pointer to a COM object</A><br>
+			<A href="#intrusive">Using a <code>shared_ptr</code> to hold a pointer to an object 
+				with an embedded reference count</A><br>
+			<A href="#another_sp">Using a <code>shared_ptr</code> to hold another shared 
+				ownership smart pointer</A><br>
+			<A href="#from_raw">Obtaining a <code>shared_ptr</code> from a raw pointer</A><br>
+			<A href="#in_constructor">Obtaining a <code>shared_ptr</code> (<code>weak_ptr</code>) 
+				to <code>this</code> in a constructor</A><br>
+			<A href="#from_this">Obtaining a <code>shared_ptr</code> to <code>this</code></A><br>
+			<A href="#handle">Using <code>shared_ptr</code> as a smart counted handle</A><br>
+			<A href="#on_block_exit">Using <code>shared_ptr</code> to execute code on block 
+				exit</A><br>
+			<A href="#pvoid">Using <code>shared_ptr&lt;void&gt;</code> to hold an arbitrary 
+				object</A><br>
+			<A href="#extra_data">Associating arbitrary data with heterogeneous <code>shared_ptr</code>
+				instances</A><br>
+			<A href="#as_lock">Using <code>shared_ptr</code> as a CopyConstructible mutex lock</A><br>
+			<A href="#wrapper">Using <code>shared_ptr</code> to wrap member function calls</A><br>
+			<A href="#delayed">Delayed deallocation</A><br>
+			<A href="#weak_without_shared">Weak pointers to objects not managed by a <code>shared_ptr</code></A><br>
+		</p>
+		<h2><A name="incomplete">Using incomplete classes for implementation hiding</A></h2>
+		<p>A proven technique (that works in C, too) for separating interface from 
+			implementation is to use a pointer to an incomplete class as an opaque handle:</p>
+		<pre>class FILE;
+
+FILE * fopen(char const * name, char const * mode);
+void fread(FILE * f, void * data, size_t size);
+void fclose(FILE * f);
+</pre>
+		<p>It is possible to express the above interface using <code>shared_ptr</code>, 
+			eliminating the need to manually call <code>fclose</code>:</p>
+		<pre>class FILE;
+
+shared_ptr&lt;FILE&gt; fopen(char const * name, char const * mode);
+void fread(shared_ptr&lt;FILE&gt; f, void * data, size_t size);
+</pre>
+		<p>This technique relies on <code>shared_ptr</code>'s ability to execute a custom 
+			deleter, eliminating the explicit call to <code>fclose</code>, and on the fact 
+			that <code>shared_ptr&lt;X&gt;</code> can be copied and destroyed when <code>X</code>
+			is incomplete.</p>
+		<h2><A name="pimpl">The "Pimpl" idiom</A></h2>
+		<p>A C++ specific variation of the incomplete class pattern is the "Pimpl" idiom. 
+			The incomplete class is not exposed to the user; it is hidden behind a 
+			forwarding facade. <code>shared_ptr</code> can be used to implement a "Pimpl":</p>
+		<pre>// file.hpp:
+
+class file
+{
+private:
+
+    class impl;
+    shared_ptr&lt;impl&gt; pimpl_;
+
+public:
+
+    file(char const * name, char const * mode);
+
+    // compiler generated members are fine and useful
+
+    void read(void * data, size_t size);
+};
+</pre>
+		<pre>// file.cpp:
+
+#include "file.hpp"
+
+class file::impl
+{
+private:
+
+    impl(impl const &amp;);
+    impl &amp; operator=(impl const &amp;);
+
+    // private data
+
+public:
+
+    impl(char const * name, char const * mode) { ... }
+    ~impl() { ... }
+    void read(void * data, size_t size) { ... }
+};
+
+file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
+{
+}
+
+void file::read(void * data, size_t size)
+{
+    pimpl_-&gt;read(data, size);
+}
+</pre>
+		<p>The key thing to note here is that the compiler-generated copy constructor, 
+			assignment operator, and destructor all have a sensible meaning. As a result, <code>
+				file</code> is <code>CopyConstructible</code> and <code>Assignable</code>, 
+			allowing its use in standard containers.</p>
+		<h2><A name="abstract">Using abstract classes for implementation hiding</A></h2>
+		<p>Another widely used C++ idiom for separating inteface and implementation is to 
+			use abstract base classes and factory functions. The abstract classes are 
+			sometimes called "interfaces" and the pattern is known as "interface-based 
+			programming". Again, <code>shared_ptr</code> can be used as the return type of 
+			the factory functions:</p>
+		<pre>// X.hpp:
+
+class X
+{
+public:
+
+    virtual void f() = 0;
+    virtual void g() = 0;
+
+protected:
+
+    ~X() {}
+};
+
+shared_ptr&lt;X&gt; createX();
+</pre>
+		<pre>-- X.cpp:
+
+class X_impl: public X
+{
+private:
+
+    X_impl(X_impl const &amp;);
+    X_impl &amp; operator=(X_impl const &amp;);
+
+public:
+
+    virtual void f()
+    {
+      // ...
+    }
+
+    virtual void g()
+    {
+      // ...
+    }
+};
+
+shared_ptr&lt;X&gt; createX()
+{
+    shared_ptr&lt;X&gt; px(new X_impl);
+    return px;
+}
+</pre>
+		<p>A key property of shared_ptr is that the allocation, construction, deallocation, 
+			and destruction details are captured at the point of construction, inside the 
+			factory function. Note the protected and nonvirtual destructor in the example 
+			above. The client code cannot, and does not need to, delete a pointer to <code>X</code>; 
+			the <code>shared_ptr&lt;X&gt;</code> instance returned from <code>createX</code>
+			will correctly call <code>~X_impl</code>.</p>
+		<h2><A name="preventing_delete">Preventing <code>delete px.get()</code></A></h2>
+		<p>It is often desirable to prevent client code from deleting a pointer that is 
+			being managed by <code>shared_ptr</code>. The previous technique showed one 
+			possible approach, using a protected destructor. Another alternative is to use 
+			a private deleter:</p>
+		<pre>class X
+{
+private:
+
+    ~X();
+
+    class deleter;
+    friend class deleter;
+
+    class deleter
+    {
+    public:
+
+        void operator()(X * p) { delete p; }
+    };
+
+public:
+
+    static shared_ptr&lt;X&gt; create()
+    {
+        shared_ptr&lt;X&gt; px(new X, X::deleter());
+        return px;
+    }
+};
+</pre>
+		<h2><A name="array">Using a <code>shared_ptr</code> to hold a pointer to an array</A></h2>
+		<p>A <code>shared_ptr</code> can be used to hold a pointer to an array allocated 
+			with <code>new[]</code>:</p>
+		<pre>shared_ptr&lt;X&gt; px(new X[1], <A href="../utility/checked_delete.html" >checked_array_deleter</A>&lt;X&gt;());
+</pre>
+		<p>Note, however, that <code><A href="shared_array.htm">shared_array</A></code> is 
+			often preferable, if this is an option. It has an array-specific interface, 
+			without <code>operator*</code> and <code>operator-&gt;</code>, and does not 
+			allow pointer conversions.</p>
+		<h2><A name="encapsulation">Encapsulating allocation details, wrapping factory 
+				functions</A></h2>
+		<p><code>shared_ptr</code> can be used in creating C++ wrappers over existing C 
+			style library interfaces that return raw pointers from their factory functions 
+			to encapsulate allocation details. As an example, consider this interface, 
+			where <code>CreateX</code> might allocate <code>X</code> from its own private 
+			heap, <code>~X</code> may be inaccessible, or <code>X</code> may be incomplete:</p>
+		<pre>X * CreateX();
+void DestroyX(X *);
+</pre>
+		<p>The only way to reliably destroy a pointer returned by <code>CreateX</code> is 
+			to call <code>DestroyX</code>.</p>
+		<P>Here is how a <code>shared_ptr</code>-based wrapper may look like:</P>
+		<pre>shared_ptr&lt;X&gt; createX()
+{
+    shared_ptr&lt;X&gt; px(CreateX(), DestroyX);
+    return px;
+}
+</pre>
+		<p>Client code that calls <code>createX</code> still does not need to know how the 
+			object has been allocated, but now the destruction is automatic.</p>
+		<h2><A name="static">Using a <code>shared_ptr</code> to hold a pointer to a statically 
+				allocated object</A></h2>
+		<p>Sometimes it is desirable to create a <code>shared_ptr</code> to an already 
+			existing object, so that the <code>shared_ptr</code> does not attempt to 
+			destroy the object when there are no more references left. As an example, the 
+			factory function:</p>
+		<pre>shared_ptr&lt;X&gt; createX();
+</pre>
+		<p>in certain situations may need to return a pointer to a statically allocated <code>X</code>
+			instance.</p>
+		<P>The solution is to use a custom deleter that does nothing:</P>
+		<pre>struct null_deleter
+{
+    void operator()(void const *) const
+    {
+    }
+};
+
+static X x;
+
+shared_ptr&lt;X&gt; createX()
+{
+    shared_ptr&lt;X&gt; px(&amp;x, null_deleter());
+    return px;
+}
+</pre>
+		<p>The same technique works for any object known to outlive the pointer.</p>
+		<h2><A name="com">Using a <code>shared_ptr</code> to hold a pointer to a COM Object</A></h2>
+		<p>Background: COM objects have an embedded reference count and two member 
+			functions that manipulate it. <code>AddRef()</code> increments the count. <code>Release()</code>
+			decrements the count and destroys itself when the count drops to zero.</p>
+		<P>It is possible to hold a pointer to a COM object in a <code>shared_ptr</code>:</P>
+		<pre>shared_ptr&lt;IWhatever&gt; make_shared_from_COM(IWhatever * p)
+{
+    p-&gt;AddRef();
+    shared_ptr&lt;IWhatever&gt; pw(p, <A href="../bind/mem_fn.html" >mem_fn</A>(&amp;IWhatever::Release));
+    return pw;
+}
+</pre>
+		<p>Note, however, that <code>shared_ptr</code> copies created from <code>pw</code> will 
+			not "register" in the embedded count of the COM object; they will share the 
+			single reference created in <code>make_shared_from_COM</code>. Weak pointers 
+			created from <code>pw</code> will be invalidated when the last <code>shared_ptr</code>
+			is destroyed, regardless of whether the COM object itself is still alive.</p>
+		<h2><A name="intrusive">Using a <code>shared_ptr</code> to hold a pointer to an object 
+				with an embedded reference count</A></h2>
+		<p>This is a generalization of the above technique. The example assumes that the 
+			object implements the two functions required by <code><A href="intrusive_ptr.html">intrusive_ptr</A></code>,
+			<code>intrusive_ptr_add_ref</code> and <code>intrusive_ptr_release</code>:</p>
+		<pre>template&lt;class T&gt; struct intrusive_deleter
+{
+    void operator()(T * p)
+    {
+        if(p) intrusive_ptr_release(p);
+    }
+};
+
+shared_ptr&lt;X&gt; make_shared_from_intrusive(X * p)
+{
+    if(p) intrusive_ptr_add_ref(p);
+    shared_ptr&lt;X&gt; px(p, intrusive_deleter&lt;X&gt;());
+    return px;
+}
+</pre>
+		<h2><A name="another_sp">Using a <code>shared_ptr</code> to hold another shared 
+				ownership smart pointer</A></h2>
+		<p>One of the design goals of <code>shared_ptr</code> is to be used in library 
+			interfaces. It is possible to encounter a situation where a library takes a <code>shared_ptr</code>
+			argument, but the object at hand is being managed by a different reference 
+			counted or linked smart pointer.</p>
+		<P>It is possible to exploit <code>shared_ptr</code>'s custom deleter feature to 
+			wrap this existing smart pointer behind a <code>shared_ptr</code> facade:</P>
+		<pre>template&lt;class P&gt; struct smart_pointer_deleter
+{
+private:
+
+    P p_;
+
+public:
+
+    smart_pointer_deleter(P const &amp; p): p_(p)
+    {
+    }
+
+    void operator()(void const *)
+    {
+        p_.reset();
+    }
+    
+    P const &amp; get() const
+    {
+        return p_;
+    }
+};
+
+shared_ptr&lt;X&gt; make_shared_from_another(another_ptr&lt;X&gt; qx)
+{
+    shared_ptr&lt;X&gt; px(qx.get(), smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt;(qx));
+    return px;
+}
+</pre>
+		<p>One subtle point is that deleters are not allowed to throw exceptions, and the 
+			above example as written assumes that <code>p_.reset()</code> doesn't throw. If 
+			this is not the case, <code>p_.reset()</code> should be wrapped in a <code>try {} 
+				catch(...) {}</code> block that ignores exceptions. In the (usually 
+			unlikely) event when an exception is thrown and ignored, <code>p_</code> will 
+			be released when the lifetime of the deleter ends. This happens when all 
+			references, including weak pointers, are destroyed or reset.</p>
+		<P>Another twist is that it is possible, given the above <code>shared_ptr</code> instance, 
+			to recover the original smart pointer, using <code><A href="shared_ptr.htm#get_deleter">
+					get_deleter</A></code>:</P>
+		<pre>void extract_another_from_shared(shared_ptr&lt;X&gt; px)
+{
+    typedef smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt; deleter;
+
+    if(deleter const * pd = get_deleter&lt;deleter&gt;(px))
+    {
+        another_ptr&lt;X&gt; qx = pd-&gt;get();
+    }
+    else
+    {
+        // not one of ours
+    }
+}
+</pre>
+		<h2><A name="from_raw">Obtaining a <code>shared_ptr</code> from a raw pointer</A></h2>
+		<p>Sometimes it is necessary to obtain a <code>shared_ptr</code> given a raw 
+			pointer to an object that is already managed by another <code>shared_ptr</code> 
+			instance. Example:</p>
+		<pre>void f(X * p)
+{
+    shared_ptr&lt;X&gt; px(<i>???</i>);
+}
+</pre>
+		<p>Inside <code>f</code>, we'd like to create a <code>shared_ptr</code> to <code>*p</code>.</p>
+		<P>In the general case, this problem has no solution. One approach is to modify <code>f</code>
+			to take a <code>shared_ptr</code>, if possible:</P>
+		<pre>void f(shared_ptr&lt;X&gt; px);
+</pre>
+		<p>The same transformation can be used for nonvirtual member functions, to convert 
+			the implicit <code>this</code>:</p>
+		<pre>void X::f(int m);
+</pre>
+		<p>would become a free function with a <code>shared_ptr</code> first argument:</p>
+		<pre>void f(shared_ptr&lt;X&gt; this_, int m);
+</pre>
+		<p>If <code>f</code> cannot be changed, but <code>X</code> uses intrusive counting, 
+			use <code><A href="#intrusive">make_shared_from_intrusive</A></code> described 
+			above. Or, if it's known that the <code>shared_ptr</code> created in <code>f</code>
+			will never outlive the object, use <A href="#static">a null deleter</A>.</p>
+		<h2><A name="in_constructor">Obtaining a <code>shared_ptr</code> (<code>weak_ptr</code>) 
+				to <code>this</code> in a constructor</A></h2>
+		<p>Some designs require objects to register themselves on construction with a 
+			central authority. When the registration routines take a shared_ptr, this leads 
+			to the question how could a constructor obtain a shared_ptr to this:</p>
+		<pre>class X
+{
+public:
+
+    X()
+    {
+        shared_ptr&lt;X&gt; this_(<i>???</i>);
+    }
+};
+</pre>
+		<p>In the general case, the problem cannot be solved. The <code>X</code> instance 
+			being constructed can be an automatic variable or a static variable; it can be 
+			created on the heap:</p>
+		<pre>shared_ptr&lt;X&gt; px(new X);</pre>
+		<P>but at construction time, <code>px</code> does not exist yet, and it is 
+			impossible to create another <code>shared_ptr</code> instance that shares 
+			ownership with it.</P>
+		<P>Depending on context, if the inner <code>shared_ptr</code> <code>this_</code> doesn't 
+			need to keep the object alive, use a <code>null_deleter</code> as explained <A href="#static">
+				here</A> and <A href="#weak_without_shared">here</A>. If <code>X</code> is 
+			supposed to always live on the heap, and be managed by a <code>shared_ptr</code>, 
+			use a static factory function:</P>
+		<pre>class X
+{
+private:
+
+    X() { ... }
+
+public:
+
+    static shared_ptr&lt;X&gt; create()
+    {
+        shared_ptr&lt;X&gt; px(new X);
+        // use px as 'this_'
+        return px;
+    }
+};
+</pre>
+		<h2><A name="from_this">Obtaining a <code>shared_ptr</code> to <code>this</code></A></h2>
+		<p>Sometimes it is needed to obtain a <code>shared_ptr</code> from <code>this</code>
+			in a virtual member function under the assumption that <code>this</code> is 
+			already managed by a <code>shared_ptr</code>. The transformations <A href="#from_raw">
+				described in the previous technique</A> cannot be applied.</p>
+		<P>A typical example:</P>
+		<pre>class X
+{
+public:
+
+    virtual void f() = 0;
+
+protected:
+
+    ~X() {}
+};
+
+class Y
+{
+public:
+
+    virtual shared_ptr&lt;X&gt; getX() = 0;
+
+protected:
+
+    ~Y() {}
+};
+
+// --
+
+class impl: public X, public Y
+{
+public:
+
+    impl() { ... }
+
+    virtual void f() { ... }
+
+    virtual shared_ptr&lt;X&gt; getX()
+    {
+        shared_ptr&lt;X&gt; px(<i>???</i>);
+        return px;
+    }
+};
+</pre>
+		<p>The solution is to keep a weak pointer to <code>this</code> as a member in <code>impl</code>:</p>
+		<pre>class impl: public X, public Y
+{
+private:
+
+    weak_ptr&lt;impl&gt; weak_this;
+
+    impl(impl const &amp;);
+    impl &amp; operator=(impl const &amp;);
+
+    impl() { ... }
+
+public:
+
+    static shared_ptr&lt;impl&gt; create()
+    {
+        shared_ptr&lt;impl&gt; pi(new impl);
+        pi-&gt;weak_this = pi;
+        return pi;
+    }
+
+    virtual void f() { ... }
+
+    virtual shared_ptr&lt;X&gt; getX()
+    {
+        shared_ptr&lt;X&gt; px(weak_this);
+        return px;
+    }
+};
+</pre>
+		<p>The library now includes a helper class template <code><A href="enable_shared_from_this.html">
+					enable_shared_from_this</A></code> that can be used to encapsulate the 
+			solution:</p>
+		<pre>class impl: public X, public Y, public enable_shared_from_this&lt;impl&gt;
+{
+public:
+
+    impl(impl const &amp;);
+    impl &amp; operator=(impl const &amp;);
+
+public:
+
+    virtual void f() { ... }
+
+    virtual shared_ptr&lt;X&gt; getX()
+    {
+        return shared_from_this();
+    }
+}
+</pre>
+		<h2><A name="handle">Using <code>shared_ptr</code> as a smart counted handle</A></h2>
+		<p>Some library interfaces use opaque handles, a variation of the <A href="#incomplete">
+				incomplete class technique</A> described above. An example:</p>
+		<pre>typedef void * HANDLE;
+HANDLE CreateProcess();
+void CloseHandle(HANDLE);
+</pre>
+		<p>Instead of a raw pointer, it is possible to use <code>shared_ptr</code> as the 
+			handle and get reference counting and automatic resource management for free:</p>
+		<pre>typedef shared_ptr&lt;void&gt; handle;
+
+handle createProcess()
+{
+    shared_ptr&lt;void&gt; pv(CreateProcess(), CloseHandle);
+    return pv;
+}
+</pre>
+		<h2><A name="on_block_exit">Using <code>shared_ptr</code> to execute code on block exit</A></h2>
+		<p><code>shared_ptr&lt;void&gt;</code> can automatically execute cleanup code when 
+			control leaves a scope.</p>
+		<UL>
+			<LI>
+				Executing <code>f(p)</code>, where <code>p</code> is a pointer:</LI></UL>
+		<pre>    shared_ptr&lt;void&gt; guard(p, f);
+</pre>
+		<UL>
+			<LI>
+				Executing arbitrary code: <code>f(x, y)</code>:</LI></UL>
+		<pre>    shared_ptr&lt;void&gt; guard(static_cast&lt;void*&gt;(0), <A href="../bind/bind.html" >bind</A>(f, x, y));
+</pre>
+		<P>For a more thorough treatment, see the article "Simplify Your Exception-Safe 
+			Code" by Andrei Alexandrescu and Petru Marginean, available online at <A href="http://www.cuj.com/experts/1812/alexandr.htm?topic=experts">
+				http://www.cuj.com/experts/1812/alexandr.htm?topic=experts</A>.</P>
+		<h2><A name="pvoid">Using <code>shared_ptr&lt;void&gt;</code> to hold an arbitrary 
+				object</A></h2>
+		<p><code>shared_ptr&lt;void&gt;</code> can act as a generic object pointer similar 
+			to <code>void*</code>. When a <code>shared_ptr&lt;void&gt;</code> instance 
+			constructed as:</p>
+		<pre>    shared_ptr&lt;void&gt; pv(new X);
+</pre>
+		<p>is destroyed, it will correctly dispose of the <code>X</code> object by 
+			executing <code>~X</code>.</p>
+		<p>This propery can be used in much the same manner as a raw <code>void*</code> is 
+			used to temporarily strip type information from an object pointer. A <code>shared_ptr&lt;void&gt;</code>
+			can later be cast back to the correct type by using <code><A href="shared_ptr.htm#static_pointer_cast">
+					static_pointer_cast</A></code>.</p>
+		<h2><A name="extra_data">Associating arbitrary data with heterogeneous <code>shared_ptr</code>
+				instances</A></h2>
+		<p><code>shared_ptr</code> and <code>weak_ptr</code> support <code>operator&lt;</code>
+			comparisons required by standard associative containers such as <code>std::map</code>. 
+			This can be used to non-intrusively associate arbitrary data with objects 
+			managed by <code>shared_ptr</code>:</p>
+		<pre>typedef int Data;
+
+std::map&lt; shared_ptr&lt;void&gt;, Data &gt; userData;
+// or std::map&lt; weak_ptr&lt;void&gt;, Data &gt; userData; to not affect the lifetime
+
+shared_ptr&lt;X&gt; px(new X);
+shared_ptr&lt;int&gt; pi(new int(3));
+
+userData[px] = 42;
+userData[pi] = 91;
+</pre>
+		<h2><A name="as_lock">Using <code>shared_ptr</code> as a CopyConstructible mutex lock</A></h2>
+		<p>Sometimes it's necessary to return a mutex lock from a function, and a 
+			noncopyable lock cannot be returned by value. It is possible to use <code>shared_ptr</code>
+			as a mutex lock:</p>
+		<pre>class mutex
+{
+public:
+
+    void lock();
+    void unlock();
+};
+
+shared_ptr&lt;mutex&gt; lock(mutex &amp; m)
+{
+    m.lock();
+    return shared_ptr&lt;mutex&gt;(&amp;m, mem_fn(&amp;mutex::unlock));
+}
+</pre>
+		<p>Better yet, the <code>shared_ptr</code> instance acting as a lock can be 
+			encapsulated in a dedicated <code>shared_lock</code> class:</p>
+		<pre>class shared_lock
+{
+private:
+
+    shared_ptr&lt;void&gt; pv;
+
+public:
+
+    template&lt;class Mutex&gt; explicit shared_lock(Mutex &amp; m): pv((m.lock(), &amp;m), mem_fn(&amp;Mutex::unlock)) {}
+};
+</pre>
+		<p><code>shared_lock</code> can now be used as:</p>
+		<pre>    shared_lock lock(m);
+</pre>
+		<p>Note that <code>shared_lock</code> is not templated on the mutex type, thanks to <code>
+				shared_ptr&lt;void&gt;</code>'s ability to hide type information.</p>
+		<h2><A name="wrapper">Using <code>shared_ptr</code> to wrap member function calls</A></h2>
+		<p><code>shared_ptr</code> implements the ownership semantics required from the <code>Wrap</code>/<code>CallProxy</code>
+			scheme described in Bjarne Stroustrup's article "Wrapping C++ Member Function 
+			Calls" (available online at <A href="http://www.research.att.com/~bs/wrapper.pdf">http://www.research.att.com/~bs/wrapper.pdf</A>). 
+			An implementation is given below:</p>
+		<pre>template&lt;class T&gt; class pointer
+{
+private:
+
+    T * p_;
+
+public:
+
+    explicit pointer(T * p): p_(p)
+    {
+    }
+
+    shared_ptr&lt;T&gt; operator-&gt;() const
+    {
+        p_-&gt;prefix();
+        return shared_ptr&lt;T&gt;(p_, <A href="../bind/mem_fn.html" >mem_fn</A>(&amp;T::suffix));
+    }
+};
+
+class X
+{
+private:
+
+    void prefix();
+    void suffix();
+    friend class pointer&lt;X&gt;;
+    
+public:
+
+    void f();
+    void g();
+};
+
+int main()
+{
+    X x;
+
+    pointer&lt;X&gt; px(&amp;x);
+
+    px-&gt;f();
+    px-&gt;g();
+}
+</pre>
+		<h2><A name="delayed">Delayed deallocation</A></h2>
+		<p>In some situations, a single <code>px.reset()</code> can trigger an expensive 
+			deallocation in a performance-critical region:</p>
+		<pre>class X; // ~X is expensive
+
+class Y
+{
+    shared_ptr&lt;X&gt; px;
+
+public:
+
+    void f()
+    {
+        px.reset();
+    }
+};
+</pre>
+		<p>The solution is to postpone the potential deallocation by moving <code>px</code> 
+			to a dedicated free list that can be periodically emptied when performance and 
+			response times are not an issue:</p>
+		<pre>vector&lt; shared_ptr&lt;void&gt; &gt; free_list;
+
+class Y
+{
+    shared_ptr&lt;X&gt; px;
+
+public:
+
+    void f()
+    {
+        free_list.push_back(px);
+        px.reset();
+    }
+};
+
+// periodically invoke free_list.clear() when convenient
+</pre>
+		<p>Another variation is to move the free list logic to the construction point by 
+			using a delayed deleter:</p>
+		<pre>struct delayed_deleter
+{
+    template&lt;class T&gt; void operator()(T * p)
+    {
+        try
+        {
+            shared_ptr&lt;void&gt; pv(p);
+            free_list.push_back(pv);
+        }
+        catch(...)
+        {
+        }
+    }
+};
+</pre>
+		<h2><A name="weak_without_shared">Weak pointers to objects not managed by a <code>shared_ptr</code></A></h2>
+		<p>Make the object hold a <code>shared_ptr</code> to itself, using a <code>null_deleter</code>:</p>
+		<pre>class X
+{
+private:
+
+    shared_ptr&lt;X&gt; this_;
+    int i_;
+
+public:
+
+    explicit X(int i): this_(this, null_deleter()), i_(i)
+    {
+    }
+
+    // repeat in all constructors (including the copy constructor!)
+
+    X(X const &amp; rhs): this_(this, null_deleter()), i_(rhs.i_)
+    {
+    }
+
+    // do not forget to not assign this_ in the copy assignment
+
+    X &amp; operator=(X const &amp; rhs)
+    {
+	    i_ = rhs.i_;
+    }
+
+    weak_ptr&lt;X&gt; get_weak_ptr() const { return this_; }
+};
+</pre>
+		<p>When the object's lifetime ends, <code>X::this_</code> will be destroyed, and 
+			all weak pointers will automatically expire.</p>
+		<hr>
+		<p>$Date$</p>
+		<p><small>Copyright <20> 2003 Peter Dimov. 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.</small></p>
+	</body>
+</html>
--- a/src/sp_collector.cpp
+++ b/src/sp_collector.cpp
@@ -0,0 +1,268 @@
+//
+//  sp_collector.cpp
+//
+//  Copyright (c) 2002, 2003 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)
+//
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+#include <boost/assert.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/detail/lightweight_mutex.hpp>
+#include <cstdlib>
+#include <map>
+#include <deque>
+#include <iostream>
+
+typedef std::map< void const *, std::pair<void *, size_t> > map_type;
+
+static map_type & get_map()
+{
+    static map_type m;
+    return m;
+}
+
+typedef boost::detail::lightweight_mutex mutex_type;
+
+static mutex_type & get_mutex()
+{
+    static mutex_type m;
+    return m;
+}
+
+static void * init_mutex_before_main = &get_mutex();
+
+namespace
+{
+    class X;
+
+    struct count_layout
+    {
+        boost::detail::sp_counted_base * pi;
+        int id;
+    };
+
+    struct shared_ptr_layout
+    {
+        X * px;
+        count_layout pn;
+    };
+}
+
+// assume 4 byte alignment for pointers when scanning
+size_t const pointer_align = 4;
+
+typedef std::map<void const *, long> map2_type;
+
+static void scan_and_count(void const * area, size_t size, map_type const & m, map2_type & m2)
+{
+    unsigned char const * p = static_cast<unsigned char const *>(area);
+
+    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
+    {
+        shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
+
+        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m.count(q->pn.pi) != 0)
+        {
+            ++m2[q->pn.pi];
+        }
+    }
+}
+
+typedef std::deque<void const *> open_type;
+
+static void scan_and_mark(void const * area, size_t size, map2_type & m2, open_type & open)
+{
+    unsigned char const * p = static_cast<unsigned char const *>(area);
+
+    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
+    {
+        shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
+
+        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m2.count(q->pn.pi) != 0)
+        {
+            open.push_back(q->pn.pi);
+            m2.erase(q->pn.pi);
+        }
+    }
+}
+
+static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
+{
+    // scan objects for shared_ptr members, compute internal counts
+
+    {
+        std::cout << "... " << m.size() << " objects in m.\n";
+
+        for(map_type::const_iterator i = m.begin(); i != m.end(); ++i)
+        {
+            boost::detail::sp_counted_base const * p = static_cast<boost::detail::sp_counted_base const *>(i->first);
+
+            BOOST_ASSERT(p->use_count() != 0); // there should be no inactive counts in the map
+
+            scan_and_count(i->second.first, i->second.second, m, m2);
+        }
+
+        std::cout << "... " << m2.size() << " objects in m2.\n";
+    }
+
+    // mark reachable objects
+
+    {
+        open_type open;
+
+        for(map2_type::iterator i = m2.begin(); i != m2.end(); ++i)
+        {
+            boost::detail::sp_counted_base const * p = static_cast<boost::detail::sp_counted_base const *>(i->first);
+            if(p->use_count() != i->second) open.push_back(p);
+        }
+
+        std::cout << "... " << m2.size() << " objects in open.\n";
+
+        for(open_type::iterator j = open.begin(); j != open.end(); ++j)
+        {
+            m2.erase(*j);
+        }
+
+        while(!open.empty())
+        {
+            void const * p = open.front();
+            open.pop_front();
+
+            map_type::const_iterator i = m.find(p);
+            BOOST_ASSERT(i != m.end());
+
+            scan_and_mark(i->second.first, i->second.second, m2, open);
+        }
+    }
+
+    // m2 now contains the unreachable objects
+}
+
+std::size_t find_unreachable_objects(bool report)
+{
+    map2_type m2;
+
+#ifdef BOOST_HAS_THREADS
+
+    // This will work without the #ifdef, but some compilers warn
+    // that lock is not referenced
+
+    mutex_type::scoped_lock lock(get_mutex());
+
+#endif
+
+    map_type const & m = get_map();
+
+    find_unreachable_objects_impl(m, m2);
+
+    if(report)
+    {
+        for(map2_type::iterator j = m2.begin(); j != m2.end(); ++j)
+        {
+            map_type::const_iterator i = m.find(j->first);
+            BOOST_ASSERT(i != m.end());
+            std::cout << "Unreachable object at " << i->second.first << ", " << i->second.second << " bytes long.\n";
+        }
+    }
+
+    return m2.size();
+}
+
+typedef std::deque< boost::shared_ptr<X> > free_list_type;
+
+static void scan_and_free(void * area, size_t size, map2_type const & m2, free_list_type & free)
+{
+    unsigned char * p = static_cast<unsigned char *>(area);
+
+    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
+    {
+        shared_ptr_layout * q = reinterpret_cast<shared_ptr_layout *>(p);
+
+        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m2.count(q->pn.pi) != 0 && q->px != 0)
+        {
+            boost::shared_ptr<X> * ppx = reinterpret_cast< boost::shared_ptr<X> * >(p);
+            free.push_back(*ppx);
+            ppx->reset();
+        }
+    }
+}
+
+void free_unreachable_objects()
+{
+    free_list_type free;
+
+    {
+        map2_type m2;
+
+#ifdef BOOST_HAS_THREADS
+
+        mutex_type::scoped_lock lock(get_mutex());
+
+#endif
+
+        map_type const & m = get_map();
+
+        find_unreachable_objects_impl(m, m2);
+
+        for(map2_type::iterator j = m2.begin(); j != m2.end(); ++j)
+        {
+            map_type::const_iterator i = m.find(j->first);
+            BOOST_ASSERT(i != m.end());
+            scan_and_free(i->second.first, i->second.second, m2, free);
+        }
+    }
+
+    std::cout << "... about to free " << free.size() << " objects.\n";
+}
+
+// debug hooks
+
+namespace boost
+{
+
+void sp_scalar_constructor_hook(void *)
+{
+}
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn)
+{
+#ifdef BOOST_HAS_THREADS
+
+    mutex_type::scoped_lock lock(get_mutex());
+
+#endif
+
+    get_map()[pn] = std::make_pair(px, size);
+}
+
+void sp_scalar_destructor_hook(void *)
+{
+}
+
+void sp_scalar_destructor_hook(void *, std::size_t, void * pn)
+{
+#ifdef BOOST_HAS_THREADS
+
+    mutex_type::scoped_lock lock(get_mutex());
+
+#endif
+
+    get_map().erase(pn);
+}
+
+void sp_array_constructor_hook(void *)
+{
+}
+
+void sp_array_destructor_hook(void *)
+{
+}
+
+} // namespace boost
+
+#endif // defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
--- a/src/sp_debug_hooks.cpp
+++ b/src/sp_debug_hooks.cpp
@@ -0,0 +1,243 @@
+//
+//  sp_debug_hooks.cpp
+//
+//  Copyright (c) 2002, 2003 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)
+//
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+#include <boost/assert.hpp>
+#include <new>
+#include <cstdlib>
+
+int const m = 2; // m * sizeof(int) must be aligned appropriately
+
+// magic values to mark heap blocks with
+
+int const allocated_scalar  = 0x1234560C;
+int const allocated_array   = 0x1234560A;
+int const adopted_scalar    = 0x0567890C;
+int const adopted_array     = 0x0567890A;
+int const deleted           = 0x498769DE;
+
+using namespace std; // for compilers where things aren't in std
+
+// operator new
+
+static new_handler get_new_handler()
+{
+    new_handler p = set_new_handler(0);
+    set_new_handler(p);
+    return p;
+}
+
+static void * allocate(size_t n, int mark)
+{
+    int * pm;
+
+    for(;;)
+    {
+        pm = static_cast<int*>(malloc(n + m * sizeof(int)));
+
+        if(pm != 0) break;
+
+        if(new_handler pnh = get_new_handler())
+        {
+            pnh();
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    *pm = mark;
+
+    return pm + m;
+}
+
+void * operator new(size_t n) throw(bad_alloc)
+{
+    void * p = allocate(n, allocated_scalar);
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+
+    if(p == 0) throw bad_alloc();
+
+#endif
+
+    return p;
+}
+
+#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+
+void * operator new(size_t n, nothrow_t const &) throw()
+{
+    return allocate(n, allocated_scalar);
+}
+
+#endif
+
+void * operator new[](size_t n) throw(bad_alloc)
+{
+    void * p = allocate(n, allocated_array);
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+
+    if(p == 0) throw bad_alloc();
+
+#endif
+
+    return p;
+}
+
+#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+
+void * operator new[](size_t n, nothrow_t const &) throw()
+{
+    return allocate(n, allocated_array);
+}
+
+#endif
+
+// debug hooks
+
+namespace boost
+{
+
+void sp_scalar_constructor_hook(void * p)
+{
+    if(p == 0) return;
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm != adopted_scalar);    // second smart pointer to the same address
+    BOOST_ASSERT(*pm != allocated_array);   // allocated with new[]
+    BOOST_ASSERT(*pm == allocated_scalar);  // not allocated with new
+
+    *pm = adopted_scalar;
+}
+
+void sp_scalar_constructor_hook(void * px, std::size_t, void *)
+{
+    sp_scalar_constructor_hook(px);
+}
+
+void sp_scalar_destructor_hook(void * p)
+{
+    if(p == 0) return;
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm == adopted_scalar);    // attempt to destroy nonmanaged block
+
+    *pm = allocated_scalar;
+}
+
+void sp_scalar_destructor_hook(void * px, std::size_t, void *)
+{
+    sp_scalar_destructor_hook(px);
+}
+
+// It is not possible to handle the array hooks in a portable manner.
+// The implementation typically reserves a bit of storage for the number
+// of objects in the array, and the argument of the array hook isn't
+// equal to the return value of operator new[].
+
+void sp_array_constructor_hook(void * /* p */)
+{
+/*
+    if(p == 0) return;
+
+    // adjust p depending on the implementation
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm != adopted_array);     // second smart array pointer to the same address
+    BOOST_ASSERT(*pm != allocated_scalar);  // allocated with new
+    BOOST_ASSERT(*pm == allocated_array);   // not allocated with new[]
+
+    *pm = adopted_array;
+*/
+}
+
+void sp_array_destructor_hook(void * /* p */)
+{
+/*
+    if(p == 0) return;
+
+    // adjust p depending on the implementation
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm == adopted_array); // attempt to destroy nonmanaged block
+
+    *pm = allocated_array;
+*/
+}
+
+} // namespace boost
+
+// operator delete
+
+void operator delete(void * p) throw()
+{
+    if(p == 0) return;
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm != deleted);           // double delete
+    BOOST_ASSERT(*pm != adopted_scalar);    // delete p.get();
+    BOOST_ASSERT(*pm != allocated_array);   // allocated with new[]
+    BOOST_ASSERT(*pm == allocated_scalar);  // not allocated with new
+
+    *pm = deleted;
+
+    free(pm);
+}
+
+#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+
+void operator delete(void * p, nothrow_t const &) throw()
+{
+    ::operator delete(p);
+}
+
+#endif
+
+void operator delete[](void * p) throw()
+{
+    if(p == 0) return;
+
+    int * pm = static_cast<int*>(p);
+    pm -= m;
+
+    BOOST_ASSERT(*pm != deleted);           // double delete
+    BOOST_ASSERT(*pm != adopted_scalar);    // delete p.get();
+    BOOST_ASSERT(*pm != allocated_scalar);  // allocated with new
+    BOOST_ASSERT(*pm == allocated_array);   // not allocated with new[]
+
+    *pm = deleted;
+
+    free(pm);
+}
+
+#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+
+void operator delete[](void * p, nothrow_t const &) throw()
+{
+    ::operator delete[](p);
+}
+
+#endif
+
+#endif // defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -0,0 +1,41 @@
+#  Boost.SmartPtr Library test Jamfile
+#
+#  Copyright (c) 2003 Peter Dimov
+#  Copyright (c) 2003 Dave Abrahams
+#
+#  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.
+
+subproject libs/smart_ptr/test ;
+
+# bring in rules for testing
+import testing ;
+
+# Make tests run by default.
+DEPENDS all : smart_ptr ;
+
+{
+    test-suite "smart_ptr"
+        : [ run smart_ptr_test.cpp ]
+          [ run shared_ptr_basic_test.cpp : : : <gcc><*><cxxflags>-Wno-non-virtual-dtor ]
+          [ run shared_ptr_test.cpp : : : <gcc><*><cxxflags>-Wno-non-virtual-dtor ]
+          [ run weak_ptr_test.cpp ]
+          [ run shared_from_this_test.cpp : : : <gcc><*><cxxflags>-Wno-non-virtual-dtor ]
+          [ run get_deleter_test.cpp ]
+          [ run intrusive_ptr_test.cpp ]
+          [ run intrusive_ptr_test.cpp ]
+          [ compile-fail shared_ptr_assign_fail.cpp ]
+        ;
+    
+    # this one is too slow to run unless explicitly requested, and ALL
+    # tests are run by default when this file is subincluded from
+    # boost/status, so it's guarded from that case.  It will only be
+    # built from this directory when the targets "test" (all tests) or
+    # "shared_ptr_alloc_test" are requested.
+    if [ in-invocation-subdir ]
+    {
+        run shared_ptr_alloc_test.cpp ;
+    }
+}
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -0,0 +1,36 @@
+#  Boost.SmartPtr Library test Jamfile
+#
+#  Copyright (c) 2003 Peter Dimov
+#  Copyright (c) 2003 Dave Abrahams
+#
+#  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.
+
+# bring in rules for testing
+import testing ;
+
+{
+    test-suite "smart_ptr"
+        : [ run smart_ptr_test.cpp ]
+          [ run shared_ptr_basic_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
+          [ run shared_ptr_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
+          [ run weak_ptr_test.cpp ]
+          [ run shared_from_this_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
+          [ run get_deleter_test.cpp ]
+          [ run intrusive_ptr_test.cpp ]
+          [ compile-fail shared_ptr_assign_fail.cpp ]
+        ;
+    
+    # this one is too slow to run unless explicitly requested, and ALL
+    # tests are run by default when this file is subincluded from
+    # boost/status, so it's guarded from that case.  It will only be
+    # built from this directory when the targets "test" (all tests) or
+    # "shared_ptr_alloc_test" are requested.
+    #!!!
+    #if [ in-invocation-subdir ]
+    #{
+    #    run shared_ptr_alloc_test.cpp ;
+    #}
+}
--- a/test/collector_test.cpp
+++ b/test/collector_test.cpp
@@ -0,0 +1,99 @@
+//
+//  collector_test.cpp
+//
+//  Copyright (c) 2003 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/shared_ptr.hpp>
+#include <vector>
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+
+// sp_collector.cpp exported functions
+
+std::size_t find_unreachable_objects(bool report);
+void free_unreachable_objects();
+
+struct X
+{
+    void* fill[32];
+    boost::shared_ptr<X> p;
+};
+
+void report()
+{
+    std::cout << "Calling find_unreachable_objects:\n";
+
+    std::clock_t t = std::clock();
+
+    std::size_t n = find_unreachable_objects(false);
+
+    t = std::clock() - t;
+
+    std::cout << n << " unreachable objects.\n";
+    std::cout << "  " << static_cast<double>(t) / CLOCKS_PER_SEC << " seconds.\n";
+}
+
+void free()
+{
+    std::cout << "Calling free_unreachable_objects:\n";
+
+    std::clock_t t = std::clock();
+
+    free_unreachable_objects();
+
+    t = std::clock() - t;
+
+    std::cout << "  " << static_cast<double>(t) / CLOCKS_PER_SEC << " seconds.\n";
+}
+
+int main()
+{
+    std::vector< boost::shared_ptr<X> > v1, v2;
+
+    int const n = 256 * 1024;
+
+    std::cout << "Filling v1 and v2\n";
+
+    for(int i = 0; i < n; ++i)
+    {
+        v1.push_back(boost::shared_ptr<X>(new X));
+        v2.push_back(boost::shared_ptr<X>(new X));
+    }
+
+    report();
+
+    std::cout << "Creating the cycles\n";
+
+    for(int i = 0; i < n - 1; ++i)
+    {
+        v2[i]->p = v2[i+1];
+    }
+
+    v2[n-1]->p = v2[0];
+
+    report();
+
+    std::cout << "Resizing v2 to size of 1\n";
+
+    v2.resize(1);
+    report();
+
+    std::cout << "Clearing v2\n";
+
+    v2.clear();
+    report();
+
+    std::cout << "Clearing v1\n";
+
+    v1.clear();
+    report();
+
+    free();
+    report();
+}
--- a/test/get_deleter_test.cpp
+++ b/test/get_deleter_test.cpp
@@ -0,0 +1,95 @@
+//
+//  get_deleter_test.cpp
+//
+//  Copyright (c) 2002 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/shared_ptr.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+struct deleter
+{
+    int data;
+
+    deleter(): data(0)
+    {
+    }
+
+    void operator()(void *)
+    {
+        BOOST_TEST(data == 17041);
+    }
+};
+
+struct deleter2
+{
+};
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        boost::shared_ptr<X> p;
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        boost::shared_ptr<X> p(new X);
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+    }
+
+    {
+        X x;
+        boost::shared_ptr<X> p(&x, deleter());
+
+        BOOST_TEST(boost::get_deleter<void>(p) == 0);
+        BOOST_TEST(boost::get_deleter<void const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int>(p) == 0);
+        BOOST_TEST(boost::get_deleter<int const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X>(p) == 0);
+        BOOST_TEST(boost::get_deleter<X const>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2>(p) == 0);
+        BOOST_TEST(boost::get_deleter<deleter2 const>(p) == 0);
+
+        deleter * q = boost::get_deleter<deleter>(p);
+
+        BOOST_TEST(q != 0);
+        BOOST_TEST(q->data == 0);
+
+        q->data = 17041;
+
+        deleter const * r = boost::get_deleter<deleter const>(p);
+
+        BOOST_TEST(r == q);
+        BOOST_TEST(r->data == 17041);
+    }
+
+    return boost::report_errors();
+}
--- a/test/intrusive_ptr_test.cpp
+++ b/test/intrusive_ptr_test.cpp
@@ -0,0 +1,560 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#pragma warning(disable: 4355)  // 'this' : used in base member initializer list
+#pragma warning(disable: 4511)  // copy constructor could not be generated
+#pragma warning(disable: 4512)  // assignment operator could not be generated
+
+#if (BOOST_MSVC >= 1310)
+#pragma warning(disable: 4675)  // resolved overload found with Koenig lookup
+#endif
+
+#endif
+
+//
+//  intrusive_ptr_test.cpp
+//
+//  Copyright (c) 2002, 2003 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/intrusive_ptr.hpp>
+#include <boost/config.hpp>
+#include <algorithm>
+#include <functional>
+
+//
+
+namespace N
+{
+
+class base
+{
+private:
+
+    long use_count_;
+
+    base(base const &);
+    base & operator=(base const &);
+
+protected:
+
+    base(): use_count_(0)
+    {
+    }
+
+    virtual ~base()
+    {
+    }
+
+public:
+
+    long use_count() const
+    {
+        return use_count_;
+    }
+
+#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+
+    inline friend void intrusive_ptr_add_ref(base * p)
+    {
+        ++p->use_count_;
+    }
+
+    inline friend void intrusive_ptr_release(base * p)
+    {
+        if(--p->use_count_ == 0) delete p;
+    }
+
+#else
+
+    void add_ref()
+    {
+        ++use_count_;
+    }
+
+    void release()
+    {
+        if(--use_count_ == 0) delete this;
+    }
+
+#endif
+};
+
+} // namespace N
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+
+namespace boost
+{
+
+inline void intrusive_ptr_add_ref(N::base * p)
+{
+    p->add_ref();
+}
+
+inline void intrusive_ptr_release(N::base * p)
+{
+    p->release();
+}
+
+} // namespace boost
+
+#endif
+
+//
+
+struct X: public virtual N::base
+{
+};
+
+struct Y: public X
+{
+};
+
+//
+
+namespace n_element_type
+{
+
+void f(X &)
+{
+}
+
+void test()
+{
+    typedef boost::intrusive_ptr<X>::element_type T;
+    T t;
+    f(t);
+}
+
+} // namespace n_element_type
+
+namespace n_constructors
+{
+
+void default_constructor()
+{
+    boost::intrusive_ptr<X> px;
+    BOOST_TEST(px.get() == 0);
+}
+
+void pointer_constructor()
+{
+    {
+        boost::intrusive_ptr<X> px(0);
+        BOOST_TEST(px.get() == 0);
+    }
+
+    {
+        boost::intrusive_ptr<X> px(0, false);
+        BOOST_TEST(px.get() == 0);
+    }
+
+    {
+        X * p = new X;
+        BOOST_TEST(p->use_count() == 0);
+
+        boost::intrusive_ptr<X> px(p);
+        BOOST_TEST(px.get() == p);
+        BOOST_TEST(px->use_count() == 1);
+    }
+
+    {
+        X * p = new X;
+        BOOST_TEST(p->use_count() == 0);
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+        using boost::intrusive_ptr_add_ref;
+#endif
+        intrusive_ptr_add_ref(p);
+        BOOST_TEST(p->use_count() == 1);
+
+        boost::intrusive_ptr<X> px(p, false);
+        BOOST_TEST(px.get() == p);
+        BOOST_TEST(px->use_count() == 1);
+    }
+}
+
+void copy_constructor()
+{
+    {
+        boost::intrusive_ptr<X> px;
+        boost::intrusive_ptr<X> px2(px);
+        BOOST_TEST(px2.get() == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<Y> py;
+        boost::intrusive_ptr<X> px(py);
+        BOOST_TEST(px.get() == py.get());
+    }
+
+    {
+        boost::intrusive_ptr<X> px(0);
+        boost::intrusive_ptr<X> px2(px);
+        BOOST_TEST(px2.get() == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<Y> py(0);
+        boost::intrusive_ptr<X> px(py);
+        BOOST_TEST(px.get() == py.get());
+    }
+
+    {
+        boost::intrusive_ptr<X> px(0, false);
+        boost::intrusive_ptr<X> px2(px);
+        BOOST_TEST(px2.get() == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<Y> py(0, false);
+        boost::intrusive_ptr<X> px(py);
+        BOOST_TEST(px.get() == py.get());
+    }
+
+    {
+        boost::intrusive_ptr<X> px(new X);
+        boost::intrusive_ptr<X> px2(px);
+        BOOST_TEST(px2.get() == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<Y> py(new Y);
+        boost::intrusive_ptr<X> px(py);
+        BOOST_TEST(px.get() == py.get());
+    }
+}
+
+void test()
+{
+    default_constructor();
+    pointer_constructor();
+    copy_constructor();
+}
+
+} // namespace n_constructors
+
+namespace n_destructor
+{
+
+void test()
+{
+    boost::intrusive_ptr<X> px(new X);
+    BOOST_TEST(px->use_count() == 1);
+
+    {
+        boost::intrusive_ptr<X> px2(px);
+        BOOST_TEST(px->use_count() == 2);
+    }
+
+    BOOST_TEST(px->use_count() == 1);
+}
+
+} // namespace n_destructor
+
+namespace n_assignment
+{
+
+void copy_assignment()
+{
+}
+
+void conversion_assignment()
+{
+}
+
+void pointer_assignment()
+{
+}
+
+void test()
+{
+    copy_assignment();
+    conversion_assignment();
+    pointer_assignment();
+}
+
+} // namespace n_assignment
+
+namespace n_access
+{
+
+void test()
+{
+    {
+        boost::intrusive_ptr<X> px;
+        BOOST_TEST(px? false: true);
+        BOOST_TEST(!px);
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+        using boost::get_pointer;
+#endif
+
+        BOOST_TEST(get_pointer(px) == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<X> px(0);
+        BOOST_TEST(px? false: true);
+        BOOST_TEST(!px);
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+        using boost::get_pointer;
+#endif
+
+        BOOST_TEST(get_pointer(px) == px.get());
+    }
+
+    {
+        boost::intrusive_ptr<X> px(new X);
+        BOOST_TEST(px? true: false);
+        BOOST_TEST(!!px);
+        BOOST_TEST(&*px == px.get());
+        BOOST_TEST(px.operator ->() == px.get());
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+        using boost::get_pointer;
+#endif
+
+        BOOST_TEST(get_pointer(px) == px.get());
+    }
+}
+
+} // namespace n_access
+
+namespace n_swap
+{
+
+void test()
+{
+    {
+        boost::intrusive_ptr<X> px;
+        boost::intrusive_ptr<X> px2;
+
+        px.swap(px2);
+
+        BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px2.get() == 0);
+
+        using std::swap;
+        swap(px, px2);
+
+        BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px2.get() == 0);
+    }
+
+    {
+        X * p = new X;
+        boost::intrusive_ptr<X> px;
+        boost::intrusive_ptr<X> px2(p);
+        boost::intrusive_ptr<X> px3(px2);
+
+        px.swap(px2);
+
+        BOOST_TEST(px.get() == p);
+        BOOST_TEST(px->use_count() == 2);
+        BOOST_TEST(px2.get() == 0);
+        BOOST_TEST(px3.get() == p);
+        BOOST_TEST(px3->use_count() == 2);
+
+        using std::swap;
+        swap(px, px2);
+
+        BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px2.get() == p);
+        BOOST_TEST(px2->use_count() == 2);
+        BOOST_TEST(px3.get() == p);
+        BOOST_TEST(px3->use_count() == 2);
+    }
+
+    {
+        X * p1 = new X;
+        X * p2 = new X;
+        boost::intrusive_ptr<X> px(p1);
+        boost::intrusive_ptr<X> px2(p2);
+        boost::intrusive_ptr<X> px3(px2);
+
+        px.swap(px2);
+
+        BOOST_TEST(px.get() == p2);
+        BOOST_TEST(px->use_count() == 2);
+        BOOST_TEST(px2.get() == p1);
+        BOOST_TEST(px2->use_count() == 1);
+        BOOST_TEST(px3.get() == p2);
+        BOOST_TEST(px3->use_count() == 2);
+
+        using std::swap;
+        swap(px, px2);
+
+        BOOST_TEST(px.get() == p1);
+        BOOST_TEST(px->use_count() == 1);
+        BOOST_TEST(px2.get() == p2);
+        BOOST_TEST(px2->use_count() == 2);
+        BOOST_TEST(px3.get() == p2);
+        BOOST_TEST(px3->use_count() == 2);
+    }
+}
+
+} // namespace n_swap
+
+namespace n_comparison
+{
+
+template<class T, class U> void test2(boost::intrusive_ptr<T> const & p, boost::intrusive_ptr<U> const & q)
+{
+    BOOST_TEST((p == q) == (p.get() == q.get()));
+    BOOST_TEST((p != q) == (p.get() != q.get()));
+}
+
+template<class T> void test3(boost::intrusive_ptr<T> const & p, boost::intrusive_ptr<T> const & q)
+{
+    BOOST_TEST((p == q) == (p.get() == q.get()));
+    BOOST_TEST((p.get() == q) == (p.get() == q.get()));
+    BOOST_TEST((p == q.get()) == (p.get() == q.get()));
+    BOOST_TEST((p != q) == (p.get() != q.get()));
+    BOOST_TEST((p.get() != q) == (p.get() != q.get()));
+    BOOST_TEST((p != q.get()) == (p.get() != q.get()));
+
+    // 'less' moved here as a g++ 2.9x parse error workaround
+    std::less<T*> less;
+    BOOST_TEST((p < q) == less(p.get(), q.get()));
+}
+
+void test()
+{
+    {
+        boost::intrusive_ptr<X> px;
+        test3(px, px);
+
+        boost::intrusive_ptr<X> px2;
+        test3(px, px2);
+
+        boost::intrusive_ptr<X> px3(px);
+        test3(px3, px3);
+        test3(px, px3);
+    }
+
+    {
+        boost::intrusive_ptr<X> px;
+
+        boost::intrusive_ptr<X> px2(new X);
+        test3(px, px2);
+        test3(px2, px2);
+
+        boost::intrusive_ptr<X> px3(new X);
+        test3(px2, px3);
+
+        boost::intrusive_ptr<X> px4(px2);
+        test3(px2, px4);
+        test3(px4, px4);
+    }
+
+    {
+        boost::intrusive_ptr<X> px(new X);
+
+        boost::intrusive_ptr<Y> py(new Y);
+        test2(px, py);
+
+        boost::intrusive_ptr<X> px2(py);
+        test2(px2, py);
+        test3(px, px2);
+        test3(px2, px2);
+    }
+}
+
+} // namespace n_comparison
+
+namespace n_static_cast
+{
+
+void test()
+{
+}
+
+} // namespace n_static_cast
+
+namespace n_dynamic_cast
+{
+
+void test()
+{
+}
+
+} // namespace n_dynamic_cast
+
+namespace n_transitive
+{
+
+struct X: public N::base
+{
+    boost::intrusive_ptr<X> next;
+};
+
+void test()
+{
+    boost::intrusive_ptr<X> p(new X);
+    p->next = boost::intrusive_ptr<X>(new X);
+    BOOST_TEST(!p->next->next);
+    p = p->next;
+    BOOST_TEST(!p->next);
+}
+
+} // namespace n_transitive
+
+namespace n_report_1
+{
+
+class foo: public N::base
+{ 
+public: 
+
+    foo(): m_self(this)
+    {
+    } 
+
+    void suicide()
+    {
+        m_self = 0;
+    }
+
+private:
+
+    boost::intrusive_ptr<foo> m_self;
+}; 
+
+void test()
+{
+    foo * foo_ptr = new foo;
+    foo_ptr->suicide();
+} 
+
+} // namespace n_report_1
+
+int main()
+{
+    n_element_type::test();
+    n_constructors::test();
+    n_destructor::test();
+    n_assignment::test();
+    n_access::test();
+    n_swap::test();
+    n_comparison::test();
+    n_static_cast::test();
+    n_dynamic_cast::test();
+
+    n_transitive::test();
+    n_report_1::test();
+
+    return boost::report_errors();
+}
--- a/test/shared_from_this_test.cpp
+++ b/test/shared_from_this_test.cpp
@@ -0,0 +1,153 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  shared_from_this_test.cpp
+//
+//  Copyright (c) 2002, 2003 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/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+
+//
+
+class X
+{
+public:
+
+    virtual void f() = 0;
+
+protected:
+
+    ~X() {}
+};
+
+class Y
+{
+public:
+
+    virtual boost::shared_ptr<X> getX() = 0;
+
+protected:
+
+    ~Y() {}
+};
+
+boost::shared_ptr<Y> createY();
+
+void test()
+{
+    boost::shared_ptr<Y> py = createY();
+    BOOST_TEST(py.get() != 0);
+    BOOST_TEST(py.use_count() == 1);
+
+    boost::shared_ptr<X> px = py->getX();
+    BOOST_TEST(px.get() != 0);
+    BOOST_TEST(py.use_count() == 2);
+
+    px->f();
+
+    boost::shared_ptr<Y> py2 = boost::dynamic_pointer_cast<Y>(px);
+    BOOST_TEST(py.get() == py2.get());
+    BOOST_TEST(!(py < py2 || py2 < py));
+    BOOST_TEST(py.use_count() == 3);
+}
+
+void test2();
+void test3();
+
+int main()
+{
+    test();
+    test2();
+    test3();
+    return boost::report_errors();
+}
+
+// virtual inheritance to stress the implementation
+// (prevents Y* -> impl*, enable_shared_from_this<impl>* -> impl* casts)
+
+class impl: public X, public virtual Y, public virtual boost::enable_shared_from_this<impl>
+{
+public:
+
+    virtual void f()
+    {
+    }
+
+    virtual boost::shared_ptr<X> getX()
+    {
+        boost::shared_ptr<impl> pi = shared_from_this();
+        BOOST_TEST(pi.get() == this);
+        return pi;
+    }
+};
+
+// intermediate impl2 to stress the implementation
+
+class impl2: public impl
+{
+};
+
+boost::shared_ptr<Y> createY()
+{
+    boost::shared_ptr<Y> pi(new impl2);
+    return pi;
+}
+
+void test2()
+{
+    boost::shared_ptr<Y> pi(static_cast<impl2*>(0));
+}
+
+//
+
+struct V: public boost::enable_shared_from_this<V>
+{
+};
+
+void test3()
+{
+    boost::shared_ptr<V> p(new V);
+
+    boost::shared_ptr<V> q = p->shared_from_this();
+    BOOST_TEST(p == q);
+    BOOST_TEST(!(p < q) && !(q < p));
+
+    V v2(*p);
+
+    try
+    {
+        boost::shared_ptr<V> r = v2.shared_from_this();
+        BOOST_ERROR("v2.shared_from_this() failed to throw");
+    }
+    catch(boost::bad_weak_ptr const &)
+    {
+    }
+
+    try
+    {
+        *p = V();
+        boost::shared_ptr<V> r = p->shared_from_this();
+        BOOST_TEST(p == r);
+        BOOST_TEST(!(p < r) && !(r < p));
+    }
+    catch(boost::bad_weak_ptr const &)
+    {
+        BOOST_ERROR("p->shared_from_this() threw bad_weak_ptr after *p = V()");
+    }
+}
--- a/test/shared_ptr_alloc_test.cpp
+++ b/test/shared_ptr_alloc_test.cpp
@@ -0,0 +1,166 @@
+//
+//  shared_ptr_alloc_test.cpp - use to evaluate the impact of count allocations
+//
+//  Copyright (c) 2002, 2003 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/shared_ptr.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/quick_allocator.hpp>
+
+#include <iostream>
+#include <vector>
+#include <ctime>
+#include <cstddef>
+#include <memory>
+
+int const n = 1024 * 1024;
+
+template<class T> void test(T * = 0)
+{
+    std::clock_t t = std::clock();
+    std::clock_t t2;
+
+    {
+        std::vector< boost::shared_ptr<T> > v;
+
+        for(int i = 0; i < n; ++i)
+        {
+            boost::shared_ptr<T> pi(new T(i));
+            v.push_back(pi);
+        }
+
+        t2 = std::clock();
+    }
+
+    std::clock_t t3 = std::clock();
+
+    std::cout << "   " << static_cast<double>(t3 - t) / CLOCKS_PER_SEC << " seconds, " << static_cast<double>(t2 - t) / CLOCKS_PER_SEC << " + " << static_cast<double>(t3 - t2) / CLOCKS_PER_SEC << ".\n";
+}
+
+class X
+{
+public:
+
+    explicit X(int n): n_(n)
+    {
+    }
+
+    void * operator new(std::size_t)
+    {
+        return std::allocator<X>().allocate(1, static_cast<X*>(0));
+    }
+
+    void operator delete(void * p)
+    {
+        std::allocator<X>().deallocate(static_cast<X*>(p), 1);
+    }
+
+private:
+
+    X(X const &);
+    X & operator=(X const &);
+
+    int n_;
+};
+
+class Y
+{
+public:
+
+    explicit Y(int n): n_(n)
+    {
+    }
+
+    void * operator new(std::size_t n)
+    {
+        return boost::detail::quick_allocator<Y>::alloc(n);
+    }
+
+    void operator delete(void * p, std::size_t n)
+    {
+        boost::detail::quick_allocator<Y>::dealloc(p, n);
+    }
+
+private:
+
+    Y(Y const &);
+    Y & operator=(Y const &);
+
+    int n_;
+};
+
+class Z: public Y
+{
+public:
+
+    explicit Z(int n): Y(n), m_(n + 1)
+    {
+    }
+
+private:
+
+    Z(Z const &);
+    Z & operator=(Z const &);
+
+    int m_;
+};
+
+int main()
+{
+    std::cout << BOOST_COMPILER "\n";
+    std::cout << BOOST_PLATFORM "\n";
+    std::cout << BOOST_STDLIB "\n";
+
+#if defined(BOOST_HAS_THREADS)
+    std::cout << "BOOST_HAS_THREADS: (defined)\n";
+#else
+    std::cout << "BOOST_HAS_THREADS: (not defined)\n";
+#endif
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+    std::cout << "BOOST_SP_USE_STD_ALLOCATOR: (defined)\n";
+#else
+    std::cout << "BOOST_SP_USE_STD_ALLOCATOR: (not defined)\n";
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+    std::cout << "BOOST_SP_USE_QUICK_ALLOCATOR: (defined)\n";
+#else
+    std::cout << "BOOST_SP_USE_QUICK_ALLOCATOR: (not defined)\n";
+#endif
+
+#if defined(BOOST_QA_PAGE_SIZE)
+    std::cout << "BOOST_QA_PAGE_SIZE: " << BOOST_QA_PAGE_SIZE << "\n";
+#else
+    std::cout << "BOOST_QA_PAGE_SIZE: (not defined)\n";
+#endif
+
+    std::cout << n << " shared_ptr<int> allocations + deallocations:\n";
+
+    test<int>();
+    test<int>();
+    test<int>();
+
+    std::cout << n << " shared_ptr<X> allocations + deallocations:\n";
+
+    test<X>();
+    test<X>();
+    test<X>();
+
+    std::cout << n << " shared_ptr<Y> allocations + deallocations:\n";
+
+    test<Y>();
+    test<Y>();
+    test<Y>();
+
+    std::cout << n << " shared_ptr<Z> allocations + deallocations:\n";
+
+    test<Z>();
+    test<Z>();
+    test<Z>();
+}
--- a/test/shared_ptr_assign_fail.cpp
+++ b/test/shared_ptr_assign_fail.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/shared_ptr.hpp>
--- a/test/shared_ptr_basic_test.cpp
+++ b/test/shared_ptr_basic_test.cpp
@@ -1,19 +1,27 @@
-#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
 #pragma warning(disable: 4514)  // unreferenced inline removed
+#pragma warning(disable: 4355)  // 'this' : used in base member initializer list
+
+#if (BOOST_MSVC >= 1310)
+#pragma warning(disable: 4675)  // resolved overload found with Koenig lookup
+#endif
+
 #endif

 //
-//  shared_ptr_test.cpp - a test for shared_ptr.hpp and weak_ptr.hpp
+//  shared_ptr_basic_test.cpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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>
@@ -21,30 +29,18 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>

-#include <iostream>
-
-bool boost_error(char const *, char const *, char const *, long)
-{
-    return true;
-}
-
-namespace
-{
-    int cnt = 0;
-}
+int cnt = 0;

 struct X
 {
    X()
    {
        ++cnt;
-        std::cout << "X(" << this << ")::X()\n";
    }

    ~X() // virtual destructor deliberately omitted
    {
        --cnt;
-        std::cout << "X(" << this << ")::~X()\n";
    }

    virtual int id() const
@@ -63,13 +59,11 @@ struct Y: public X
    Y()
    {
        ++cnt;
-        std::cout << "Y(" << this << ")::Y()\n";
    }

    ~Y()
    {
        --cnt;
-        std::cout << "Y(" << this << ")::~Y()\n";
    }

    virtual int id() const
@@ -86,7 +80,6 @@ private:
 int * get_object()
 {
    ++cnt;
-    std::cout << "get_object()\n";
    return &cnt;
 }

@@ -94,41 +87,8 @@ void release_object(int * p)
 {
    BOOST_TEST(p == &cnt);
    --cnt;
-    std::cout << "release_object()\n";
 }

-class Z: public virtual boost::counted_base
-{
-public:
-
-    Z()
-    {
-        ++cnt;
-        std::cout << "Z(" << this << ")::Z()\n";
-    }
-
-    ~Z()
-    {
-        --cnt;
-        std::cout << "Z(" << this << ")::~Z()\n";
-    }
-
-    boost::shared_ptr<Z> shared_this()
-    {
-        return boost::shared_from_this(this);
-    }
-
-    boost::shared_ptr<Z const> shared_this() const
-    {
-        return boost::shared_from_this(this);
-    }
-
-private:
-
-    Z(Z const &);
-    Z & operator= (Z const &);
-};
-
 template<class T> void test_is_X(boost::shared_ptr<T> const & p)
 {
    BOOST_TEST(p->id() == 1);
@@ -149,8 +109,9 @@ template<class T> void test_is_Y(boost::shared_ptr<T> const & p)

 template<class T> void test_is_Y(boost::weak_ptr<T> const & p)
 {
-    BOOST_TEST(p.get() != 0);
-    BOOST_TEST(p.get()->id() == 2);
+    boost::shared_ptr<T> q = p.lock();
+    BOOST_TEST(q.get() != 0);
+    BOOST_TEST(q->id() == 2);
 }

 template<class T> void test_eq(T const & a, T const & b)
@@ -169,6 +130,18 @@ template<class T> void test_ne(T const & a, T const & b)
    BOOST_TEST(!(a < b && b < a));
 }

+template<class T, class U> void test_shared(boost::weak_ptr<T> const & a, boost::weak_ptr<U> const & b)
+{
+    BOOST_TEST(!(a < b));
+    BOOST_TEST(!(b < a));
+}
+
+template<class T, class U> void test_nonshared(boost::weak_ptr<T> const & a, boost::weak_ptr<U> const & b)
+{
+    BOOST_TEST(a < b || b < a);
+    BOOST_TEST(!(a < b && b < a));
+}
+
 template<class T, class U> void test_eq2(T const & a, U const & b)
 {
    BOOST_TEST(a == b);
@@ -215,8 +188,8 @@ int main()
            test_eq(p, q);
        }

-        shared_ptr<Y> p3 = shared_dynamic_cast<Y>(p);
-        shared_ptr<Y> p4 = shared_dynamic_cast<Y>(p2);
+        shared_ptr<Y> p3 = dynamic_pointer_cast<Y>(p);
+        shared_ptr<Y> p4 = dynamic_pointer_cast<Y>(p2);

        test_is_nonzero(p3);
        test_is_zero(p4);
@@ -224,7 +197,6 @@ int main()
        BOOST_TEST(p.use_count() == 2);
        BOOST_TEST(p2.use_count() == 1);
        BOOST_TEST(p3.use_count() == 2);
-        BOOST_TEST(p4.use_count() == 1);

        test_is_Y(p3);
        test_eq2(p, p3);
@@ -235,7 +207,10 @@ int main()
        test_is_nonzero(p5);
        test_eq2(p, p5);

-        std::cout << "--\n";
+        weak_ptr<X> wp1(p2);
+
+        BOOST_TEST(!wp1.expired());
+        BOOST_TEST(wp1.use_count() != 0);

        p.reset();
        p2.reset();
@@ -247,74 +222,53 @@ int main()
        test_is_zero(p3);
        test_is_zero(p4);

-        std::cout << "--\n";
-
        BOOST_TEST(p5.use_count() == 1);

-        weak_ptr<X> wp1;
-
+        BOOST_TEST(wp1.expired());
        BOOST_TEST(wp1.use_count() == 0);
-        BOOST_TEST(wp1.get() == 0);

        try
        {
            shared_ptr<X> sp1(wp1);
            BOOST_ERROR("shared_ptr<X> sp1(wp1) failed to throw");
        }
-        catch(boost::use_count_is_zero const &)
+        catch(boost::bad_weak_ptr const &)
        {
        }

-        test_is_zero(boost::make_shared(wp1));
+        test_is_zero(wp1.lock());

-        weak_ptr<X> wp2 = shared_static_cast<X>(p5);
+        weak_ptr<X> wp2 = static_pointer_cast<X>(p5);

        BOOST_TEST(wp2.use_count() == 1);
-        BOOST_TEST(wp2.get() != 0);
        test_is_Y(wp2);
-        test_ne(wp1, wp2);
+        test_nonshared(wp1, wp2);

        // Scoped to not affect the subsequent use_count() tests.
        {
            shared_ptr<X> sp2(wp2);
-            test_is_nonzero(boost::make_shared(wp2));
+            test_is_nonzero(wp2.lock());
        }

-        weak_ptr<Y> wp3 = shared_dynamic_cast<Y>(boost::make_shared(wp2));
+        weak_ptr<Y> wp3 = dynamic_pointer_cast<Y>(wp2.lock());

        BOOST_TEST(wp3.use_count() == 1);
-        BOOST_TEST(wp3.get() != 0);
-        test_eq2(wp2, wp3);
+        test_shared(wp2, wp3);

        weak_ptr<X> wp4(wp3);

        BOOST_TEST(wp4.use_count() == 1);
-        BOOST_TEST(wp4.get() != 0);
-        test_eq(wp2, wp4);
+        test_shared(wp2, wp4);

        wp1 = p2;
-        BOOST_TEST(wp1.get() == 0);
-
-        // Note the following test. Construction succeeds,
-        // but make_shared() returns a null shared_ptr with
-        // use_count() == 2. 
-
-        shared_ptr<X> sp1(wp1);
-        test_is_zero(boost::make_shared(wp1));
-
-        BOOST_TEST(p2.use_count() == 2);
-        BOOST_TEST(sp1.use_count() == 2);
-        BOOST_TEST(wp1.use_count() == 2);
-
-        //
+        test_is_zero(wp1.lock());

        wp1 = p4;
        wp1 = wp3;
        wp1 = wp2;

        BOOST_TEST(wp1.use_count() == 1);
-        BOOST_TEST(wp1.get() != 0);
-        test_eq(wp1, wp2);
+        test_shared(wp1, wp2);

        weak_ptr<X> wp5;

@@ -324,13 +278,8 @@ int main()
        p5.reset();

        BOOST_TEST(wp1.use_count() == 0);
-        BOOST_TEST(wp1.get() == 0);
-
        BOOST_TEST(wp2.use_count() == 0);
-        BOOST_TEST(wp2.get() == 0);
-
        BOOST_TEST(wp3.use_count() == 0);
-        BOOST_TEST(wp3.get() == 0);

        // Test operator< stability for std::set< weak_ptr<> >
        // Thanks to Joe Gottman for pointing this out
@@ -342,28 +291,6 @@ int main()
            // note that both get_object and release_object deal with int*
            shared_ptr<void> p6(get_object(), release_object);
        }
-
-        {
-            // test intrusive counting
-
-            boost::shared_ptr<void> pv(new Z);
-            boost::shared_ptr<Z> pz = boost::shared_static_cast<Z>(pv);
-            BOOST_TEST(pz.use_count() == pz->use_count());
-
-            // test shared_from_this
-
-            boost::shared_ptr<Z> pz2 = pz->shared_this();
-
-            Z const & z = *pz2;
-
-            boost::shared_ptr<Z const> pz3 = z.shared_this();
-
-            BOOST_TEST(pz.use_count() == pz->use_count());
-            BOOST_TEST(pz2.use_count() == pz2->use_count());
-            BOOST_TEST(pz3.use_count() == pz3->use_count());
-            BOOST_TEST(pz.use_count() == pz2.use_count());
-            BOOST_TEST(pz.use_count() == pz3.use_count());
-        }
    }

    BOOST_TEST(cnt == 0);
--- a/test/shared_ptr_mt_test.cpp
+++ b/test/shared_ptr_mt_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/shared_ptr.hpp>
@@ -152,11 +153,13 @@ int const m = 16; // threads

 int main()
 {
-    std::printf("%s: %s, %d threads, %d iterations: ", title, implementation, m, n);
+    using namespace std; // printf, clock_t, clock
+
+    printf("%s: %s, %d threads, %d iterations: ", title, implementation, m, n);

    boost::shared_ptr<int> pi(new int(42));

-    std::clock_t t = std::clock();
+    clock_t t = clock();

    pthread_t a[m];

@@ -165,14 +168,14 @@ int main()
        a[i] = createThread( boost::bind(test, pi) );
    }

-    for(int i = 0; i < m; ++i)
+    for(int j = 0; j < m; ++j)
    {
-        pthread_join(a[i], 0);
+        pthread_join(a[j], 0);
    }

-    t = std::clock() - t;
+    t = clock() - t;

-    std::printf("\n\n%.3f seconds.\n", static_cast<double>(t) / CLOCKS_PER_SEC);
+    printf("\n\n%.3f seconds.\n", static_cast<double>(t) / CLOCKS_PER_SEC);

    return 0;
 }
--- a/test/shared_ptr_test.cpp
+++ b/test/shared_ptr_test.cpp
--- a/test/shared_ptr_timing_test.cpp
+++ b/test/shared_ptr_timing_test.cpp
@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@@ -10,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/shared_ptr.hpp>
@@ -25,17 +26,21 @@ int const n = 8 * 1024 * 1024;

 int main()
 {
+    using namespace std;
+
    std::vector< boost::shared_ptr<int> > v;
    boost::shared_ptr<int> pi(new int);

-    std::clock_t t = std::clock();
+    clock_t t = clock();

    for(int i = 0; i < n; ++i)
    {
        v.push_back(pi);
    }

-    t = std::clock() - t;
+    t = clock() - t;

    std::cout << static_cast<double>(t) / CLOCKS_PER_SEC << '\n';
+
+    return 0;
 }
--- a/test/smart_ptr_test.cpp
+++ b/test/smart_ptr_test.cpp
@@ -1,9 +1,10 @@
 //  smart pointer test program  ----------------------------------------------//

-//  (C) Copyright Beman Dawes 1998, 1999. 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 Beman Dawes 1998, 1999.  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)
+
+//  See http://www.boost.org/libs/smart_ptr for documentation.

 //  Revision History
 //  24 May 01  use Boost test library for error detection, reporting, add tests
@@ -13,6 +14,25 @@
 //  20 Jul 99  header name changed to .hpp
 //  20 Apr 99  additional error tests added.

+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+
+# pragma warning(disable: 4786)  // identifier truncated in debug info
+# pragma warning(disable: 4710)  // function not inlined
+# pragma warning(disable: 4711)  // function selected for automatic inline expansion
+# pragma warning(disable: 4514)  // unreferenced inline removed
+
+#if (BOOST_MSVC >= 1310)
+# pragma warning(disable: 4675)  // resolved overload found with Koenig lookup
+#endif
+
+#endif
+
+#ifdef __BORLANDC__
+# pragma warn -8092 // template argument passed to 'find' is not an iterator
+#endif
+
 #include <boost/scoped_ptr.hpp>
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
@@ -24,11 +44,6 @@
 #include <iostream>
 #include <set>

-bool boost_error(char const *, char const *, char const *, long)
-{
-  return true; // fail with assert()
-}
-
 class Incomplete;

 Incomplete * get_ptr(  boost::shared_ptr<Incomplete>& incomplete )
@@ -42,7 +57,7 @@ using boost::scoped_array;
 using boost::shared_ptr;
 using boost::shared_array;

-template<typename T>
+template<class T>
 void ck( const T* v1, T v2 ) { BOOST_TEST( *v1 == v2 ); }

 namespace {
@@ -164,7 +179,6 @@ void test()
    cp.reset();
    BOOST_TEST( cp2.use_count() == 2 );
    BOOST_TEST( cp3.use_count() == 2 );
-    BOOST_TEST( cp.use_count() == 1 );
    cp.reset( new int );
    *cp =  98765;
    BOOST_TEST( *cp == 98765 );
--- a/test/weak_ptr_test.cpp
+++ b/test/weak_ptr_test.cpp
--- a/weak_ptr.htm
+++ b/weak_ptr.htm
@@ -4,32 +4,39 @@
 		<title>weak_ptr</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-	<body bgcolor="#ffffff" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">weak_ptr 
+	<body text="#000000" bgColor="#ffffff">
+		<h1><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle">weak_ptr 
 			class template</h1>
-		<p>The <b>weak_ptr</b> class template stores a&nbsp;"weak reference"&nbsp;to an 
-			object that's already managed by a <b>shared_ptr</b>. To access the object, a <STRONG>
-				weak_ptr</STRONG> can be converted to a <STRONG>shared_ptr</STRONG> using <A href="shared_ptr.htm#constructors">
-				the <STRONG>shared_ptr</STRONG> constructor</A> or the function <STRONG><A href="#make_shared">
-					make_shared</A></STRONG>. When the last <b>shared_ptr</b> to the object 
-			goes away and the object is deleted,&nbsp;the attempt to obtain a <STRONG>shared_ptr</STRONG>
-			&nbsp;from the <b>weak_ptr</b> instances that refer to the deleted object will 
-			fail: the constructor will throw an exception of type <STRONG>boost::use_count_is_zero</STRONG>, 
-			and <STRONG>make_shared</STRONG> will return a default constructed (null) <STRONG>shared_ptr</STRONG>.</p>
+		<p><A href="#Introduction">Introduction</A><br>
+			<A href="#Synopsis">Synopsis</A><br>
+			<A href="#Members">Members</A><br>
+			<A href="#functions">Free Functions</A><br>
+			<A href="#FAQ">Frequently Asked Questions</A>
+		</p>
+		<h2><a name="Introduction">Introduction</a></h2>
+		<p>The <b>weak_ptr</b> class template stores a "weak reference" to an object that's 
+			already managed by a <b>shared_ptr</b>. To access the object, a <STRONG>weak_ptr</STRONG>
+			can be converted to a <STRONG>shared_ptr</STRONG> using <A href="shared_ptr.htm#constructors">
+				the <STRONG>shared_ptr</STRONG> constructor</A> or the member function <STRONG><A href="#lock">
+					lock</A></STRONG>. When the last <b>shared_ptr</b> to the object goes 
+			away and the object is deleted, the attempt to obtain a <STRONG>shared_ptr</STRONG>
+			from the <b>weak_ptr</b> instances that refer to the deleted object will fail: 
+			the constructor will throw an exception of type <STRONG>boost::bad_weak_ptr</STRONG>, 
+			and <STRONG>weak_ptr::lock</STRONG> will return an <EM>empty</EM> <STRONG>shared_ptr</STRONG>.</p>
 		<p>Every <b>weak_ptr</b> meets the <b>CopyConstructible</b> and <b>Assignable</b> requirements 
 			of the C++ Standard Library, and so can be used in standard library containers. 
 			Comparison operators are supplied so that <b>weak_ptr</b> works with the 
 			standard library's associative containers.</p>
+		<P><STRONG>weak_ptr</STRONG> operations never throw&nbsp;exceptions.</P>
 		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-			to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">
-				common requirements</a>.</p>
-		<P>Compared to&nbsp;<STRONG>shared_ptr</STRONG>, <STRONG>weak_ptr</STRONG> provides 
-			a very limited subset of operations since accessing its stored pointer is 
-			often&nbsp;dangerous in multithreaded&nbsp;programs, and sometimes unsafe even 
-			within a single thread&nbsp;(that is, it may invoke undefined behavior.) 
-			Consider, for example, this innocent piece of code:</P>
-		<pre>
-shared_ptr&lt;int&gt; p(new int(5));
+			to.</p>
+		<P>Compared to <STRONG>shared_ptr</STRONG>, <STRONG>weak_ptr</STRONG> provides a 
+			very limited subset of operations since accessing its stored pointer is often 
+			dangerous in multithreaded programs, and sometimes unsafe even within a single 
+			thread (that is, it may invoke undefined behavior.) Pretend for a moment that <b>weak_ptr</b>
+			has a <b>get</b> member function that returns a raw pointer, and consider this 
+			innocent piece of code:</P>
+		<pre>shared_ptr&lt;int&gt; p(new int(5));
 weak_ptr&lt;int&gt; q(p);

 // some time later
@@ -44,60 +51,54 @@ if(int * r = q.get())
 			is a dangling pointer.</P>
 		<P>The solution to this problem is to create a temporary <STRONG>shared_ptr</STRONG>
 			from <STRONG>q</STRONG>:</P>
-		<pre>
-shared_ptr&lt;int&gt; p(new int(5));
+		<pre>shared_ptr&lt;int&gt; p(new int(5));
 weak_ptr&lt;int&gt; q(p);

 // some time later

-if(shared_ptr&lt;int&gt; r = <a href="#make_shared">make_shared</a>(q))
+if(shared_ptr&lt;int&gt; r = q.<A href="#lock" >lock</A>())
 {
    // use *r
 }
 </pre>
 		<p>Now <STRONG>r</STRONG> holds a reference to the object that was pointed by <STRONG>q</STRONG>. 
 			Even if <code>p.reset()</code> is executed in another thread, the object will 
-			stay alive until <STRONG>r</STRONG> goes out of scope (or is reset.)</p>
+			stay alive until <STRONG>r</STRONG> goes out of scope or is reset. By obtaining 
+			a <STRONG>shared_ptr</STRONG> to the object, we have effectively locked it 
+			against destruction.</p>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {

-  template&lt;typename T&gt; class weak_ptr {
+  template&lt;class T&gt; class weak_ptr {

    public:
-      typedef T <a href="#element_type">element_type</a>;
+      typedef T <A href="#element_type" >element_type</A>;

-      <a href="#constructors">weak_ptr</a>();
-      template&lt;typename Y&gt; <a href="#constructors">weak_ptr</a>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-      <a href="#destructor">~weak_ptr</a>(); // never throws
+      <A href="#default-constructor" >weak_ptr</A>();

-      <a href="#constructors">weak_ptr</a>(weak_ptr const &amp; r); // never throws
-      template&lt;typename Y&gt; <a href="#constructors">weak_ptr</a>(weak_ptr&lt;Y&gt; const &amp; r); // never throws
+      template&lt;class Y&gt; <A href="#constructors" >weak_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r);
+      <A href="#constructors" >weak_ptr</A>(weak_ptr const &amp; r);
+      template&lt;class Y&gt; <A href="#constructors" >weak_ptr</A>(weak_ptr&lt;Y&gt; const &amp; r);

-      weak_ptr &amp; <a href="#assignment">operator=</a>(weak_ptr const &amp; r); // never throws  
-      template&lt;typename Y&gt; weak_ptr &amp; <a href="#assignment">operator=</a>(weak_ptr&lt;Y&gt; const &amp; r); // never throws
-      template&lt;typename Y&gt; weak_ptr &amp; <a href="#assignment">operator=</a>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
+      <A href="#destructor" >~weak_ptr</A>();

-      void <a href="#reset">reset</a>();
-      T * <a href="#get">get</a>() const; // never throws; deprecated, will disappear
+      weak_ptr &amp; <A href="#assignment" >operator=</A>(weak_ptr const &amp; r);
+      template&lt;class Y&gt; weak_ptr &amp; <A href="#assignment" >operator=</A>(weak_ptr&lt;Y&gt; const &amp; r);
+      template&lt;class Y&gt; weak_ptr &amp; <A href="#assignment" >operator=</A>(shared_ptr&lt;Y&gt; const &amp; r);

-      long <a href="#use_count">use_count</a>() const; // never throws
-      bool <a href="#expired">expired</a>() const; // never throws
+      long <A href="#use_count" >use_count</A>() const;
+      bool <A href="#expired" >expired</A>() const;
+      shared_ptr&lt;T&gt; <A href="#lock" >lock</A>() const;

-      void <a href="#swap">swap</a>(weak_ptr&lt;T&gt; &amp; b); // never throws
+      void <A href="#reset" >reset</A>();
+      void <A href="#swap" >swap</A>(weak_ptr&lt;T&gt; &amp; b);
  };

-  template&lt;typename T, typename U&gt;
-    bool <a href="#comparison">operator==</a>(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b); // never throws
-  template&lt;typename T, typename U&gt;
-    bool <a href="#comparison">operator!=</a>(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b); // never throws
-  template&lt;typename T&gt;
-    bool <a href="#comparison">operator&lt;</a>(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;T&gt; const &amp; b); // never throws
-
-  template&lt;typename T&gt; void <a href="#free-swap">swap</a>(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b); // never throws
-
-  template&lt;typename T&gt;
-    shared_ptr&lt;T&gt; <a href="#make_shared">make_shared</a>(weak_ptr&lt;T&gt; const &amp; r); // never throws
+  template&lt;class T, class U&gt;
+    bool <A href="#comparison" >operator&lt;</A>(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b);

+  template&lt;class T&gt;
+    void <A href="#free-swap" >swap</A>(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b);
 }
 </pre>
 		<h2><a name="Members">Members</a></h2>
@@ -106,153 +107,139 @@ if(shared_ptr&lt;int&gt; r = <a href="#make_shared">make_shared</a>(q))
 		<blockquote>
 			<p>Provides the type of the template parameter T.</p>
 		</blockquote>
-		<h3><a name="constructors">constructors</a></h3>
-		<pre> weak_ptr();</pre>
+		<h3><a name="default-constructor">constructors</a></h3>
+		<pre>weak_ptr();</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>weak_ptr</b>.</p>
-			<p><b>Postconditions:</b> <A href="#use_count">use count</A> is 0; the stored 
-				pointer is 0.</p>
-			<p><b>Throws:</b> <b>std::bad_alloc</b>.</p>
-			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
-				effect.</p>
-			<P><B>Notes:</B> <B>T</B> need not be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
-		</blockquote>
-		<pre>template&lt;typename Y&gt; weak_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
-		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>weak_ptr</b>, as if by storing a copy of the 
-				pointer stored in <b>r</b>.</p>
+			<p><b>Effects:</b> Constructs an <EM>empty</EM> <b>weak_ptr</b>.</p>
+			<p><b>Postconditions:</b> <code>use_count() == 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> The <a href="#use_count">use count</a> for all copies is 
-				unchanged. When the last <b>shared_ptr</b> is destroyed, the use count and 
-				stored pointer become 0.</P>
-		</blockquote>
-		<pre>weak_ptr(weak_ptr const &amp; r); // never throws
-template&lt;typename Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
+		</blockquote><a name="constructors"></a>
+		<pre>template&lt;class Y&gt; weak_ptr</A>(shared_ptr&lt;Y&gt; const &amp; r);
+weak_ptr(weak_ptr const &amp; r);
+template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>weak_ptr</b>, as if by storing a copy of the 
+			<p><b>Effects:</b> If <STRONG>r</STRONG> is <EM>empty</EM>, constructs an <EM>empty</EM>
+				<STRONG>weak_ptr</STRONG>; otherwise, constructs a <b>weak_ptr</b> that <EM>shares 
+					ownership</EM> with <STRONG>r</STRONG> as if by storing a copy of the 
 				pointer stored in <b>r</b>.</p>
+			<p><b>Postconditions:</b> <code>use_count() == r.use_count()</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> The <a href="#use_count">use count</a> for all copies is 
-				unchanged.</P>
 		</blockquote>
 		<h3><a name="destructor">destructor</a></h3>
-		<pre>~weak_ptr(); // never throws</pre>
+		<pre>~weak_ptr();</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Destroys this <b>weak_ptr</b> but has no effect on the object 
 				its stored pointer points to.</P>
 			<P><B>Throws:</B> nothing.</P>
-			<P><B>Notes:</B> <B>T</B> need not be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
 		</BLOCKQUOTE>
 		<h3><a name="assignment">assignment</a></h3>
-		<pre>weak_ptr &amp; <a href="#assignment">operator=</a>(weak_ptr const &amp; r); // never throws
-template&lt;typename Y&gt; weak_ptr &amp; <a href="#assignment">operator=</a>(weak_ptr&lt;Y&gt; const &amp; r); // never throws
-template&lt;typename Y&gt; weak_ptr &amp; <a href="#assignment">operator=</a>(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
+		<pre>weak_ptr &amp; operator=(weak_ptr const &amp; r);
+template&lt;class Y&gt; weak_ptr &amp; operator=(weak_ptr&lt;Y&gt; const &amp; r);
+template&lt;class Y&gt; weak_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>weak_ptr(r).swap(*this)</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> The implementation is free to meet the effects (and the implied 
 				guarantees) via different means, without creating a temporary.</P>
 		</BLOCKQUOTE>
+		<h3><a name="use_count">use_count</a></h3>
+		<pre>long use_count() const;</pre>
+		<blockquote>
+			<p><b>Returns:</b> if <STRONG>*this</STRONG> is <EM>empty</EM>, an unspecified 
+				nonnegative value; otherwise, the number of <b>shared_ptr</b> objects that <EM>share 
+					ownership</EM> with <STRONG>*this</STRONG>.</p>
+			<p><b>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
+				for debugging and testing purposes, not for production code.</P>
+		</blockquote>
+		<h3><a name="expired">expired</a></h3>
+		<pre>bool expired() const;</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>use_count() == 0</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> <code>expired()</code> may be faster than <code>use_count()</code>.</P>
+		</blockquote>
+		<h3><a name="lock">lock</a></h3>
+		<pre>shared_ptr&lt;T&gt; lock() const;</pre>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>expired()? shared_ptr&lt;T&gt;(): shared_ptr&lt;T&gt;(*this)</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset();</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>weak_ptr().swap(*this)</code>.</P>
 		</BLOCKQUOTE>
-		<h3><a name="get">get</a></h3>
-		<pre>T * get() const; // never throws</pre>
-		<blockquote>
-			<p><b>Returns:</b> the stored pointer (0 if all <b>shared_ptr</b> objects for that 
-				pointer are destroyed.)</p>
-			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> Using <b>get</b> in multithreaded code is dangerous. After the 
-				function returns, the pointed-to object may be destroyed by a different thread, 
-				since the <b>weak_ptr</b> doesn't affect its <b>use_count</b>.</P>
-		</blockquote>
-		<P><EM>[<b>get</b> is&nbsp;very error-prone. Even single-threaded code may experience 
-				problems, as the returned pointer may be invalidated at any time, for example, 
-				indirectly by a member function of the pointee.</EM></P>
-		<P><EM><STRONG>get</STRONG>&nbsp;is deprecated, and it will disappear in a future 
-				release. Do not use it.]</EM></P>
-		<h3><a name="use_count">use_count</a></h3>
-		<pre>long use_count() const; // never throws</pre>
-		<blockquote>
-			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects sharing ownership of the 
-				stored pointer.</p>
-			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
-				for debugging and testing purposes, not for production code. <B>T</B> need not 
-				be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
-		</blockquote>
-		<h3><a name="expired">expired</a></h3>
-		<pre>bool expired() const; // never throws</pre>
-		<blockquote>
-			<p><b>Returns:</b> <code>use_count() == 0</code>.</p>
-			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> <code>expired()</code> may be faster than <code>use_count()</code>.
-				<B>T</B> need not be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
-		</blockquote>
 		<h3><a name="swap">swap</a></h3>
-		<pre>void swap(weak_ptr &amp; b); // never throws</pre>
+		<pre>void swap(weak_ptr &amp; b);</pre>
 		<blockquote>
 			<p><b>Effects:</b> Exchanges the contents of the two smart pointers.</p>
 			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> <B>T</B> need not be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
 		</blockquote>
 		<h2><a name="functions">Free Functions</a></h2>
 		<h3><a name="comparison">comparison</a></h3>
-		<pre>template&lt;typename T, typename U&gt;
-  bool operator==(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b); // never throws
-template&lt;typename T, typename U&gt;
-  bool operator!=(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b); // never throws</pre>
+		<pre>template&lt;class T, class U&gt;
+  bool operator&lt;(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b);</pre>
 		<blockquote>
-			<p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
-			<p><b>Throws:</b> nothing.</p>
-			<P><B>Notes:</B> <B>T</B> need not be a complete type. See the smart pointer <A href="smart_ptr.htm#Common requirements">
-					common requirements</A>.</P>
-		</blockquote>
-		<pre>template&lt;typename T&gt;
-  bool operator&lt;(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;T&gt; const &amp; b); // never throws</pre>
-		<blockquote>
-			<p><b>Returns:</b> an implementation-defined value such that <b>operator&lt;</b> is 
-				a strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
-				of the C++ standard.</p>
+			<p><b>Returns:</b> an unspecified value such that</p>
+			<UL>
+				<LI>
+					<b>operator&lt;</b> is a strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
+				of the C++ standard;
+				<LI>
+					under the equivalence relation defined by <STRONG>operator&lt;</STRONG>, <code>!(a 
+						&lt; b) &amp;&amp; !(b &lt; a)</code>, two <STRONG>weak_ptr</STRONG> instances 
+					are equivalent if and only if they <EM>share ownership</EM>.</LI></UL>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>weak_ptr</STRONG> objects to be used as keys in 
-				associative containers. <B>T</B> need not be a complete type. See the smart 
-				pointer <A href="smart_ptr.htm#Common requirements">common requirements</A>.</P>
+				associative containers.</P>
 		</blockquote>
 		<h3><a name="free-swap">swap</a></h3>
-		<pre>template&lt;typename T&gt;
-  void swap(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b) // never throws</pre>
+		<pre>template&lt;class T&gt;
+  void swap(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b)</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
 			<P><B>Throws:</B> nothing.</P>
 			<P><B>Notes:</B> Matches the interface of <B>std::swap</B>. Provided as an aid to 
 				generic programming.</P>
 		</BLOCKQUOTE>
-		<h3><a name="make_shared">make_shared</a></h3>
-		<pre>template&lt;typename T&gt;
-  shared_ptr&lt;T&gt; make_shared(weak_ptr&lt;T&gt; &amp; const r) // never throws</pre>
-		<BLOCKQUOTE>
-			<P><B>Returns:</B> <code>r.expired()? shared_ptr&lt;T&gt;(): shared_ptr&lt;T&gt;(r)</code>.</P>
-			<P><B>Throws:</B> nothing.</P>
-		</BLOCKQUOTE>
-		<P><EM>[The current implementation of <STRONG>make_shared</STRONG> can&nbsp;propagate 
-				an exception&nbsp;thrown by the <STRONG>shared_ptr</STRONG> default 
-				constructor, so it doesn't meet the stated requirements</EM><EM>. In a future 
-				release, this default constructor will not throw.]</EM></P>
+		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
+		<P><B>Q.</B> Can an object create a <STRONG>weak_ptr</STRONG> to itself in its 
+			constructor?</P>
+		<P><b>A.</b> No. A <STRONG>weak_ptr</STRONG> can only be created from a <STRONG>shared_ptr</STRONG>, 
+			and at object construction time no <STRONG>shared_ptr</STRONG> to the object 
+			exists yet. Even if you could create a temporary <STRONG>shared_ptr</STRONG> to <STRONG>
+				this</STRONG>, it would go out of scope at the end of the constructor, and 
+			all <STRONG>weak_ptr</STRONG> instances would instantly expire.</P>
+		<P>The solution is to make the constructor private, and supply a factory function 
+			that returns a <STRONG>shared_ptr</STRONG>:<BR>
+		</P>
+		<pre>
+class X
+{
+private:
+
+    X();
+
+public:
+
+    static shared_ptr&lt;X&gt; create()
+    {
+        shared_ptr&lt;X&gt; px(new X);
+        // create weak pointers from px here
+        return px;
+    }
+};
+</pre>
+		<p><br>
+		</p>
 		<hr>
-		<p>Revised 29 August 2002<!--webbot bot="Timestamp" i-checksum="38439" endspan --></p>
-		<p>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-			Copyright 2002 Peter Dimov. 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>$Date$</p>
+		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
+				Copyright 2002, 2003 Peter Dimov. 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.</small></p>
 		</A>
 	</body>
 </html>
Author	SHA1	Message	Date
nobody	337e414515	This commit was manufactured by cvs2svn to create tag 'Version_1_32_0'. [SVN r26264]	2004-11-19 19:19:18 +00:00
Aleksey Gurtovoy	aa00436b68	fix main return type [SVN r26076]	2004-11-02 05:14:24 +00:00
nobody	8a47b48f0e	This commit was manufactured by cvs2svn to create branch 'RC_1_32_0'. [SVN r25797]	2004-10-20 08:26:43 +00:00
Aleksey Gurtovoy	c81be1e2e7	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
John Maddock	1bc58ea861	Updated to use the BSL (using permissions supplied in more/blanket-permission.txt) [SVN r24804]	2004-08-29 10:29:46 +00:00
Peter Dimov	27be736b8f	Fixed sp_enable_shared_from_this to not use void cv * since this breaks function types. [SVN r24718]	2004-08-24 16:27:31 +00:00
Douglas Gregor	ef51f6a1de	License update [SVN r24598]	2004-08-19 15:23:47 +00:00
Douglas Gregor	6b00a55542	License updates [SVN r24597]	2004-08-19 15:19:17 +00:00
John Maddock	858cefbfe8	Removed boost.org copyright assignments, and reverted to orginal author (as based on cvs history). [SVN r24402]	2004-08-11 10:59:33 +00:00
John Maddock	c7abff0099	Updated Beman Dawes' licence statement to use the new prefered form of words. [SVN r24370]	2004-08-10 10:34:20 +00:00
Douglas Gregor	cb6cb636f7	Converted to Boost Software License, Version 1.0 [SVN r24055]	2004-07-26 00:32:12 +00:00
John Maddock	366d2666d4	Licence update [SVN r24031]	2004-07-25 12:01:00 +00:00
Peter Dimov	9c67a59d43	Fixed lwm_gcc, had the same bug as atomic_count_gcc (Tyson Whitehead) [SVN r23367]	2004-07-06 10:52:06 +00:00
Peter Dimov	7361e476b8	Fixed operator-- [SVN r23210]	2004-06-27 15:40:29 +00:00
Peter Dimov	e1bd18f6a6	Made value_ mutable to enable operator long() const to compile [SVN r23208]	2004-06-27 15:09:46 +00:00
Vladimir Prus	1346982b80	Fix a typo [SVN r23077]	2004-06-10 12:31:20 +00:00
Peter Dimov	c48f05dcb4	enable_shared_from_this is now const-tolerant. [SVN r22298]	2004-02-16 18:50:07 +00:00
Peter Dimov	53cc52127b	Self-assignment optimization [SVN r22233]	2004-02-10 23:17:12 +00:00
Beman Dawes	7fb399b3bb	index.htm renamed index.html [SVN r21231]	2003-12-11 23:31:15 +00:00
Peter Dimov	93d69af60a	_MSC_VER use clarified. [SVN r20992]	2003-11-28 15:35:21 +00:00
Peter Dimov	09c8685181	Fixed a VC7 'regression' (pointers to volatile cannot be deleted) [SVN r20977]	2003-11-27 16:58:23 +00:00
Dave Abrahams	15d6b2aace	CWPro8 workaround [SVN r20323]	2003-10-09 14:14:26 +00:00
Dave Abrahams	feff6e40ea	Use conforming is_class for EDG compilers Make is_enum work for class types which are convertible to anything at all (on many compilers). smart_ptr library workarounds for __MWERKS__ (must use member function pointer for unspecified_bool_type). [SVN r20244]	2003-10-02 17:49:06 +00:00
Peter Dimov	26a93f224e	Changed index.htm to redirect to smart_ptr.htm [SVN r20239]	2003-10-01 11:13:04 +00:00
Peter Dimov	96f572b19b	Switched unspecified_bool_type to data member pointer. [SVN r20238]	2003-10-01 11:12:15 +00:00
Vladimir Prus	d6c4633e89	Add V2 Jamfile [SVN r20223]	2003-09-30 07:42:34 +00:00
Beman Dawes	106a6d58d4	Change license message to reference Boost Software License [SVN r20038]	2003-09-12 17:09:29 +00:00
Dave Abrahams	debd953d8f	Use the import rule [SVN r19968]	2003-09-08 17:38:49 +00:00
Peter Dimov	f2c5439644	'volatile' fixes. [SVN r19961]	2003-09-08 12:26:02 +00:00
Peter Dimov	b4ec0e90fb	Switched weak_count_ from #shared+#weak to #weak+(#shared != 0); thanks to Alexander Terekhov and Ben Hutchings [SVN r19246]	2003-07-21 14:17:03 +00:00
Peter Dimov	2d4eb92401	get_deleter fix for EDG 2.38 [SVN r19148]	2003-07-16 11:54:49 +00:00
Peter Dimov	192970b3b8	const_pointer_cast added. [SVN r19147]	2003-07-16 11:51:12 +00:00
Peter Dimov	7c36a640ae	add_ref split to add_ref_copy and add_ref_lock to eliminate the redundant use_count_ == 0 check. [SVN r19126]	2003-07-15 12:18:40 +00:00
Peter Dimov	794de98cd1	#include <boost/config.hpp> added. [SVN r19065]	2003-07-11 17:03:56 +00:00
Peter Dimov	dcdbaf1e57	A binary compatible 'null' lightweight_mutex for Win32 added. [SVN r18916]	2003-07-02 11:54:40 +00:00
Peter Dimov	6dbec7621d	Detect the VC6 STL, not VC6 itself (for Intel) [SVN r18837]	2003-06-18 16:03:09 +00:00
Peter Dimov	889cb6bee6	-Wundef fixes. [SVN r18788]	2003-06-12 17:09:24 +00:00
Peter Dimov	11cddbbb45	Minor fix, scoped_ptr in the intro should've been shared_ptr. [SVN r18745]	2003-06-09 18:25:41 +00:00
Peter Dimov	77c629b6e4	smart_ptr.hpp now includes all smart pointer headers for convenience. [SVN r18588]	2003-05-28 13:51:35 +00:00
Peter Dimov	d091ee85c0	Turns out Sun CC doesn't like operator int(). [SVN r18512]	2003-05-23 13:46:07 +00:00
Peter Dimov	bc00d5fa1a	Fixed bool conversions for Sun 5.3 [SVN r18419]	2003-05-16 12:11:17 +00:00
Peter Dimov	e760759414	Fixed a copy/assignment issue. [SVN r18122]	2003-03-28 12:27:55 +00:00
Peter Dimov	deab8ca1bb	Added link to enable_shared_from_this.html. [SVN r17397]	2003-02-14 10:55:20 +00:00
Peter Dimov	300f8f7b9a	Finished Techniques page, added links to it. [SVN r17380]	2003-02-13 19:07:20 +00:00
Peter Dimov	d7c841484a	Further edits, predestructor technique removed. [SVN r17374]	2003-02-13 18:35:13 +00:00
Peter Dimov	f4dce1cb88	More prose. [SVN r17369]	2003-02-13 16:56:07 +00:00
Peter Dimov	b400d34bec	Added copyright to Jamfiles. [SVN r17363]	2003-02-13 15:41:26 +00:00
Peter Dimov	8f0bdd48f8	Minor edits. [SVN r17335]	2003-02-12 19:11:52 +00:00
Peter Dimov	6d6bcc7be9	Some prose added. [SVN r17331]	2003-02-12 17:11:29 +00:00
Peter Dimov	851d87a1bb	get_shared_ptr renamed to weak_ptr::lock. [SVN r17307]	2003-02-10 15:56:36 +00:00
Peter Dimov	34f423f811	atomic_count and lightweight_mutex now report an #error on unknown threading configs. [SVN r17303]	2003-02-10 12:58:50 +00:00
Peter Dimov	190893a1ce	BOOST_ENABLE_SP_DEBUG_HOOKS -> BOOST_SP_ENABLE_DEBUG_HOOKS [SVN r17301]	2003-02-10 12:54:43 +00:00
Peter Dimov	4244992d4d	Split winapi.hpp across win32-specific headers, added BOOST_USE_WINDOWS_H option. [SVN r17277]	2003-02-08 16:05:46 +00:00
Peter Dimov	4b502993b5	Added BOOST_QA_PAGE_SIZE. [SVN r17270]	2003-02-07 18:43:48 +00:00
Peter Dimov	a24ec3988a	Quick_allocator updates. [SVN r17267]	2003-02-07 15:08:52 +00:00
Peter Dimov	23f7532a9f	Disabled some watnings. [SVN r17255]	2003-02-06 17:16:06 +00:00
Peter Dimov	a790191bc5	Small fixes. [SVN r17251]	2003-02-06 14:54:15 +00:00
Peter Dimov	86e9a322ba	Documentation fixes, make_shared -> get_shared_ptr. [SVN r17230]	2003-02-05 12:56:48 +00:00
Peter Dimov	98fa979aef	Added copyright. [SVN r17197]	2003-02-04 13:35:06 +00:00
Peter Dimov	be0267f9a3	Enabled copy assignment on all Borland versions (for Kylix) and g++ (for -Wsynth, report by Wolfgang Bangerth) [SVN r17173]	2003-02-03 13:48:33 +00:00
Dave Abrahams	44afc7e5cd	really prevent shared_ptr_alloc_test building from status/. [SVN r17097]	2003-01-30 20:57:34 +00:00
Dave Abrahams	d2c7febd26	cleanup, add shared_ptr_alloc_test. [SVN r17095]	2003-01-30 18:20:51 +00:00
Peter Dimov	ddf1f0fdcc	Fixed a deadlock in free_unreachable_objects. [SVN r17090]	2003-01-30 15:06:32 +00:00
Peter Dimov	cd41426fe9	Dave's quick_allocator added, #define BOOST_SP_USE_QUICK_ALLOCATOR to make shared_ptr use it. [SVN r17087]	2003-01-30 14:20:22 +00:00
Peter Dimov	89ea2156bc	intrusive_ptr_test.cpp added. [SVN r17051]	2003-01-27 14:09:21 +00:00
Peter Dimov	fabd6e5755	Moved 'garbage collector' to sp_collector.cpp, collector_test.cpp added. [SVN r17050]	2003-01-27 14:02:00 +00:00
Peter Dimov	b60de38d28	Fixed broken links. [SVN r17044]	2003-01-25 17:58:01 +00:00
Peter Dimov	2dbfc89d4e	Removed redundant copy constructor and copy assignment. [SVN r17043]	2003-01-25 16:51:45 +00:00
Peter Dimov	abb0d9e725	Moved smart_ptr contents to subdirectories, switched to a local test/Jamfile. [SVN r17042]	2003-01-25 16:17:17 +00:00
Peter Dimov	d030182e87	intrusive_ptr_test added. [SVN r16993]	2003-01-22 15:22:30 +00:00
Peter Dimov	bd39e2eded	intrusive_ptr.html added. [SVN r16981]	2003-01-21 17:21:24 +00:00
Peter Dimov	d04757128c	shared_ptr techniques initial commit [SVN r16978]	2003-01-21 15:55:59 +00:00
Beman Dawes	868062e81d	Add TOC and References sections [SVN r16912]	2003-01-15 16:35:48 +00:00
Peter Dimov	6bd66fe054	detail::counted_base renamed to sp_counted_base. [SVN r16900]	2003-01-14 15:13:53 +00:00
Peter Dimov	c5bae28eeb	use_count() postconditions added; enable_..._test.cpp renamed. [SVN r16896]	2003-01-13 18:32:16 +00:00
Peter Dimov	78a47d7619	Algorithm improvements, free_unreachable_objects() added. [SVN r16894]	2003-01-13 17:11:28 +00:00
Beman Dawes	8eaf187dbd	fix bookmarks [SVN r16827]	2003-01-09 13:37:41 +00:00
Beman Dawes	d36a215554	fix invalid bookmarks [SVN r16824]	2003-01-09 13:11:10 +00:00
Peter Dimov	8448bbf0b9	Fixes. [SVN r16795]	2003-01-08 15:01:04 +00:00
Peter Dimov	1dee6e0229	Small optimization. [SVN r16790]	2003-01-07 23:12:02 +00:00
Peter Dimov	e3f2329c14	report_unreachable_objects() added to sp_debug_hooks.cpp [SVN r16780]	2003-01-07 15:34:56 +00:00
Peter Dimov	3e616752c9	weak_ptr documentation updated; still a work in progress. [SVN r16748]	2003-01-04 14:24:14 +00:00
Peter Dimov	987a7d32fb	Documentation updated to reflect changes to shared_ptr [SVN r16739]	2003-01-03 16:53:04 +00:00
Dave Abrahams	fafd9a863b	Workarounds for vc6-stlport [SVN r16706]	2002-12-26 18:23:11 +00:00
Dave Abrahams	51e9783a21	Factor out get_pointer, supply an overload for std::auto_ptr. [SVN r16672]	2002-12-20 18:15:01 +00:00
Peter Dimov	eee96e8059	Borland 5.6.1 still broken. [SVN r16666]	2002-12-19 18:15:53 +00:00
Peter Dimov	1ef2a5b059	More weak_ptr tests. [SVN r16487]	2002-12-03 13:27:35 +00:00
Peter Dimov	c5f7c973d9	Bug in get_deleter fixed. [SVN r16477]	2002-12-02 14:34:06 +00:00
Peter Dimov	572a97d3c4	Casts renamed. [SVN r16457]	2002-11-29 14:05:22 +00:00
Peter Dimov	a3d87ff623	Comeau-specific fix. [SVN r16456]	2002-11-28 13:42:44 +00:00
Peter Dimov	468f63261a	weak_ptr_test.cpp added. [SVN r16427]	2002-11-26 16:01:17 +00:00
Peter Dimov	e60c1f9b49	Some versions of g++ 2.9x don't have basic_ostream. [SVN r16406]	2002-11-25 13:52:42 +00:00
Peter Dimov	72bcb8ff46	More tests added. [SVN r16405]	2002-11-25 13:51:56 +00:00
Peter Dimov	12b1871136	operator<< added, as the conversion to 'bool' implicitly defines one anyway. [SVN r16403]	2002-11-25 12:27:11 +00:00
Peter Dimov	9632464c45	Test w/ NULL pointer to enabled_... object added; bug fixed. [SVN r16402]	2002-11-25 12:17:56 +00:00
Peter Dimov	1311731e24	Moved the old shared_ptr tests into shared_ptr_basic_test.cpp [SVN r16401]	2002-11-25 12:12:45 +00:00
Peter Dimov	980307a90a	Reintroduced weak_ptr converting constructor; map<weak_ptr<>, ...> is important. [SVN r16400]	2002-11-25 12:09:13 +00:00
Peter Dimov	1f9908be69	Borland C++ 5.6 still needs the workaround. [SVN r16379]	2002-11-23 19:18:05 +00:00
Peter Dimov	0aaca2fffe	More operator< tests. [SVN r16377]	2002-11-23 12:59:01 +00:00
Peter Dimov	5dd2c62132	weak_ptr converting constructor removed; operator< can now take different types to aid ownership tests. [SVN r16376]	2002-11-23 12:47:38 +00:00
Peter Dimov	fadc0716ce	get_deleter_test added; associated fixes. [SVN r16373]	2002-11-22 16:29:51 +00:00
Peter Dimov	ea285b4231	Fixed the previous weak_ptr 'fix'. [SVN r16370]	2002-11-22 14:41:22 +00:00
Peter Dimov	8d6517484c	Stricter tests; associated bug fixes. ;-) [SVN r16369]	2002-11-22 13:49:54 +00:00
Peter Dimov	66a8e8b3c1	get_deleter<> added. [SVN r16365]	2002-11-21 14:46:45 +00:00
Peter Dimov	c697e2ef21	Sample implementation of the smart pointer debug hooks. [SVN r16364]	2002-11-21 13:23:15 +00:00
Peter Dimov	2e53e2e5d7	More tests added. [SVN r16363]	2002-11-21 13:20:46 +00:00
Peter Dimov	8283ec826b	Changed debug hook names, reverted weak_ptr() to have use_count of zero. [SVN r16362]	2002-11-21 13:14:04 +00:00
Peter Dimov	e32b2adfda	Debug hook support, removed self-reset, fixed #%20links. [SVN r16361]	2002-11-21 13:10:18 +00:00
Peter Dimov	e555d33695	Added array versions of the hooks. [SVN r16346]	2002-11-20 16:18:13 +00:00
Peter Dimov	de68e6ed1e	A missing 'inline' added. [SVN r16343]	2002-11-20 13:34:18 +00:00
Peter Dimov	804b1483c7	enable_shared_from_this-related fixes. [SVN r16341]	2002-11-20 12:38:51 +00:00
Peter Dimov	4b200e9847	Borland fix (thanks to Fernando Cacciola) [SVN r16331]	2002-11-19 18:21:32 +00:00
Peter Dimov	f34866e8a5	License added. [SVN r16326]	2002-11-19 16:23:01 +00:00
Peter Dimov	45c799f40c	Debug hook support moved to shared_count. [SVN r16325]	2002-11-19 16:18:58 +00:00
Peter Dimov	11a046f628	BOOST_ASSERTs added. [SVN r16324]	2002-11-19 16:18:18 +00:00
Peter Dimov	b632f1ef20	Debug hooks, general cleanup. [SVN r16323]	2002-11-19 16:11:21 +00:00
Peter Dimov	7f30268b10	Assignment tests added. [SVN r16322]	2002-11-19 16:10:38 +00:00
Peter Dimov	7504eff5af	A missing Returns clause added. [SVN r16321]	2002-11-19 16:10:07 +00:00
Peter Dimov	8752c00ebf	enable_shared_from_this documentation added. [SVN r16319]	2002-11-19 14:22:58 +00:00
Peter Dimov	d0c5e83def	Test for enable_shared_from_this added. [SVN r16318]	2002-11-19 13:45:33 +00:00
Peter Dimov	f6b7ff4b34	Major changes to shared_ptr and weak_ptr [SVN r16314]	2002-11-18 14:37:02 +00:00
Peter Dimov	2314f20c4e	element_type added [SVN r16264]	2002-11-15 19:44:48 +00:00
Peter Dimov	ff7410cad2	Fixed a subtle problem in counted_base::release (report and test case by Per Kristensen) [SVN r16211]	2002-11-12 13:14:50 +00:00
Peter Dimov	57c0ad44f3	Changed typename to class; some libraries helpfully #define typename [SVN r15970]	2002-10-23 13:55:18 +00:00
Peter Dimov	ae60bcaffb	Small fixes. [SVN r15951]	2002-10-17 13:23:11 +00:00
Peter Dimov	f2f616a95c	BOOST_SP_USE_STD_ALLOCATOR support [SVN r15807]	2002-10-08 16:37:33 +00:00
Peter Dimov	a8bb455df7	Fixes, notes. [SVN r15486]	2002-09-23 13:22:38 +00:00