This commit was manufactured by cvs2svn to create tag

'Version_1_29_0'. [SVN r15904]
Fixes, notes.
2025-10-04 19:51:02 +02:00 · 2002-10-11 15:17:55 +00:00 · 2002-09-23 13:32:54 +00:00 · 2002-09-19 20:49:39 +00:00 · 2002-09-18 13:00:38 +00:00 · 2002-09-17 13:59:17 +00:00
44 changed files with 5509 additions and 1385 deletions
--- a/compatibility.htm
+++ b/compatibility.htm
@@ -0,0 +1,105 @@
+<!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>Smart Pointer Changes</title>
+</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
+Pointer Changes</h1>
+
+<p>The February 2002 change to the Boost smart pointers introduced a number
+of changes. Since the previous version of the smart pointers was in use for
+a long time, it's useful to have a detailed list of what changed from a library
+user's point of view.</p>
+
+<p>Note that for compilers that don't support member templates well enough,
+a separate implementation is used that lacks many of the new features and is
+more like the old version.</p>
+
+<h2>Features Requiring Code Changes to Take Advantage</h2>
+
+<ul>
+
+<li>The smart pointer class templates now each have their own header file.
+For compatibility, the
+<a href="../../boost/smart_ptr.hpp">&lt;boost/smart_ptr.hpp&gt;</a>
+header now includes the headers for the four classic smart pointer class templates.</li>
+
+<li>The <b>weak_ptr</b> template was added.</li>
+
+<li>The new <b>shared_ptr</b> and <b>shared_array</b> relax the requirement that the pointed-to object's
+destructor must be visible when instantiating the <b>shared_ptr</b> destructor.
+This makes it easier to have shared_ptr members in classes without explicit destructors.</li>
+
+<li>A custom deallocator can be passed in when creating a <b>shared_ptr</b> or <b>shared_array</b>.</li>
+
+<li><b>shared_static_cast</b> and <b>shared_dynamic_cast</b> function templates are
+provided which work for <b>shared_ptr</b> and <b>weak_ptr</b> as <b>static_cast</b> and
+<b>dynamic_cast</b> do for pointers.</li>
+
+<li>The self-assignment misfeature has been removed from <b>shared_ptr::reset</b>,
+although it is still present in <b>scoped_ptr</b>, and in <b>std::auto_ptr</b>.
+Calling <b>reset</b> with a pointer to the object that's already owned by the
+<b>shared_ptr</b> results in undefined behavior
+(an assertion, or eventually a double-delete if assertions are off).</li>
+
+<li>The <b>BOOST_SMART_PTR_CONVERSION</b> feature has been removed.</li>
+
+<li><b>shared_ptr&lt;void&gt;</b> is now allowed.</li>
+
+</ul>
+
+<h2>Features That Improve Robustness</h2>
+
+<ul>
+
+<li>The manipulation of use counts is now <a name="threadsafe">thread safe</a> on Windows, Linux, and platforms
+that support pthreads. See the
+<a href="../../boost/detail/atomic_count.hpp">&lt;boost/detail/atomic_count.hpp&gt;</a>
+file for details</li>
+
+<li>The new shared_ptr will always delete the object using the pointer it was originally constructed with.
+This prevents subtle problems that could happen if the last <b>shared_ptr</b> was a pointer to a sub-object
+of a class that did not have a virtual destructor.</li>
+
+</ul>
+
+<h2>Implementation Details</h2>
+
+<ul>
+
+<li>Some bugs in the assignment operator implementations and in <b>reset</b>
+have been fixed by using the &quot;copy and swap&quot; idiom.</li>
+
+<li>Assertions have been added to check preconditions of various functions;
+however, since these use the new
+<a href="../../boost/assert.hpp">&lt;boost/assert.hpp&gt;</a>
+header, the assertions are disabled by default.</li>
+
+<li>The partial specialization of <b>std::less</b> has been replaced by <b>operator&lt;</b>
+overloads which accomplish the same thing without relying on undefined behavior.</li>
+
+<li>The incorrect overload of <b>std::swap</b> has been replaced by <b>boost::swap</b>, which
+has many of the same advantages for generic programming but does not violate the C++ standard.</li>
+
+</ul>
+
+<hr>
+
+<p>Revised 1 February 2002</p>
+
+<p>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 &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
--- a/include/boost/detail/atomic_count.hpp
+++ b/include/boost/detail/atomic_count.hpp
@@ -0,0 +1,123 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/atomic_count.hpp - thread/SMP safe reference counter
+//
+//  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.
+//
+//  typedef <implementation-defined> boost::detail::atomic_count;
+//
+//  atomic_count a(n);
+//
+//    (n is convertible to long)
+//
+//    Effects: Constructs an atomic_count with an initial value of n
+//
+//  a;
+//
+//    Returns: (long) the current value of a
+//
+//  ++a;
+//
+//    Effects: Atomically increments the value of a
+//    Returns: nothing
+//
+//  --a;
+//
+//    Effects: Atomically decrements the value of a
+//    Returns: (long) zero if the new value of a is zero,
+//      unspecified non-zero value otherwise (usually the new value)
+//
+//    Important note: when --a returns zero, it must act as a
+//      read memory barrier (RMB); i.e. the calling thread must
+//      have a synchronized view of the memory
+//
+//    On Intel IA-32 (x86) memory is always synchronized, so this
+//      is not a problem.
+//
+//    On many architectures the atomic instructions already act as
+//      a memory barrier.
+//
+//    This property is necessary for proper reference counting, since
+//      a thread can update the contents of a shared object, then
+//      release its reference, and another thread may immediately
+//      release the last reference causing object destruction.
+//
+//    The destructor needs to have a synchronized view of the
+//      object to perform proper cleanup.
+//
+//    Original example by Alexander Terekhov:
+//
+//    Given:
+//
+//    - a mutable shared object OBJ;
+//    - two threads THREAD1 and THREAD2 each holding 
+//      a private smart_ptr object pointing to that OBJ.
+//
+//    t1: THREAD1 updates OBJ (thread-safe via some synchronization)
+//      and a few cycles later (after "unlock") destroys smart_ptr;
+//
+//    t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization 
+//      with respect to shared mutable object OBJ; OBJ destructors
+//      are called driven by smart_ptr interface...
+//
+
+//  Note: atomic_count_linux.hpp has been disabled by default; see the
+//        comments inside for more info.
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_HAS_THREADS
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef long atomic_count;
+
+}
+
+}
+
+#elif defined(BOOST_USE_ASM_ATOMIC_H)
+#  include <boost/detail/atomic_count_linux.hpp>
+#elif defined(BOOST_AC_USE_PTHREADS)
+#  include <boost/detail/atomic_count_pthreads.hpp>
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#  include <boost/detail/atomic_count_win32.hpp>
+#elif defined(__GLIBCPP__)
+#  include <boost/detail/atomic_count_gcc.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+#  define BOOST_AC_USE_PTHREADS
+#  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;
+
+}
+
+}
+
+#endif
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_gcc.hpp
+++ b/include/boost/detail/atomic_count_gcc.hpp
@@ -0,0 +1,61 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+
+//
+//  boost/detail/atomic_count_gcc.hpp
+//
+//  atomic_count for GNU libstdc++ v3
+//
+//  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
+//
+//  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.
+//
+
+#include <bits/atomicity.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class atomic_count
+{
+public:
+
+    explicit atomic_count(long v) : value_(v) {}
+
+    void operator++()
+    {
+        __atomic_add(&value_, 1);
+    }
+
+    long operator--()
+    {
+        return !__exchange_and_add(&value_, -1);
+    }
+
+    operator long() const
+    {
+        return __exchange_and_add(&value_, 0);
+    }
+
+private:
+
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+
+    _Atomic_word value_;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_linux.hpp
+++ b/include/boost/detail/atomic_count_linux.hpp
@@ -0,0 +1,70 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
+
+//
+//  boost/detail/atomic_count_linux.hpp
+//
+//  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.
+//
+
+//
+//  This implementation uses <asm/atomic.h>. This is a kernel header;
+//  using kernel headers in a user program may cause a number of problems,
+//  and not all flavors of Linux provide the atomic instructions.
+//
+//  This file is only provided because the performance of this implementation
+//  is significantly higher than the pthreads version. Use at your own risk
+//  (by defining BOOST_USE_ASM_ATOMIC_H.)
+//
+
+#include <asm/atomic.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class atomic_count
+{
+public:
+
+    explicit atomic_count(long v)
+    {
+        atomic_t init = ATOMIC_INIT(v);
+        value_ = init;
+    }
+
+    void operator++()
+    {
+        atomic_inc(&value_);
+    }
+
+    long operator--()
+    {
+        return !atomic_dec_and_test(&value_);
+    }
+
+    operator long() const
+    {
+        return atomic_read(&value_);
+    }
+
+private:
+
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+
+    atomic_t value_;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_pthreads.hpp
+++ b/include/boost/detail/atomic_count_pthreads.hpp
@@ -0,0 +1,97 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+
+//
+//  boost/detail/atomic_count_pthreads.hpp
+//
+//  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.
+//
+
+#include <pthread.h>
+
+//
+//  The generic pthread_mutex-based implementation sometimes leads to
+//    inefficiencies. Example: a class with two atomic_count members
+//    can get away with a single mutex.
+//
+//  Users can detect this situation by checking BOOST_AC_USE_PTHREADS.
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class atomic_count
+{
+private:
+
+    class scoped_lock
+    {
+    public:
+
+        scoped_lock(pthread_mutex_t & m): m_(m)
+        {
+            pthread_mutex_lock(&m_);
+        }
+
+        ~scoped_lock()
+        {
+            pthread_mutex_unlock(&m_);
+        }
+
+    private:
+
+        pthread_mutex_t & m_;
+    };
+
+public:
+
+    explicit atomic_count(long v): value_(v)
+    {
+        pthread_mutex_init(&mutex_, 0);
+    }
+
+    ~atomic_count()
+    {
+        pthread_mutex_destroy(&mutex_);
+    }
+
+    void operator++()
+    {
+        scoped_lock lock(mutex_);
+        ++value_;
+    }
+
+    long operator--()
+    {
+        scoped_lock lock(mutex_);
+        return --value_;
+    }
+
+    operator long() const
+    {
+        scoped_lock lock(mutex_);
+        return value_;
+    }
+
+private:
+
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+
+    mutable pthread_mutex_t mutex_;
+    long value_;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
--- a/include/boost/detail/atomic_count_win32.hpp
+++ b/include/boost/detail/atomic_count_win32.hpp
@@ -0,0 +1,62 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/atomic_count_win32.hpp
+//
+//  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.
+//
+
+#include <boost/detail/winapi.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class atomic_count
+{
+public:
+
+    explicit atomic_count(long v): value_(v)
+    {
+    }
+
+    long operator++()
+    {
+        return winapi::InterlockedIncrement(&value_);
+    }
+
+    long operator--()
+    {
+        return winapi::InterlockedDecrement(&value_);
+    }
+
+    operator long() const
+    {
+        return value_;
+    }
+
+private:
+
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+
+    volatile long value_;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
--- a/include/boost/detail/lightweight_mutex.hpp
+++ b/include/boost/detail/lightweight_mutex.hpp
@@ -0,0 +1,88 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/lightweight_mutex.hpp - lightweight mutex
+//
+//  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.
+//
+//  typedef <unspecified> boost::detail::lightweight_mutex;
+//
+//  boost::detail::lightweight_mutex meets a subset of the Mutex concept
+//  requirements: http://www.boost.org/libs/thread/doc/mutex_concept.html#Mutex
+//
+//  * Used by the smart pointer library
+//  * Performance oriented
+//  * Header-only implementation
+//  * Small memory footprint
+//  * Not a general purpose mutex, use boost::mutex, CRITICAL_SECTION or
+//    pthread_mutex instead.
+//  * Never spin in a tight lock/do-something/unlock loop, since
+//    lightweight_mutex does not guarantee fairness.
+//  * Never keep a lightweight_mutex locked for long periods.
+//
+//  The current implementation can use a pthread_mutex, a CRITICAL_SECTION,
+//  or a platform-specific spinlock.
+//
+//  You can force a particular implementation by defining BOOST_LWM_USE_PTHREADS,
+//  BOOST_LWM_USE_CRITICAL_SECTION, or BOOST_LWM_USE_SPINLOCK.
+//
+//  If neither macro has been defined, the default is to use a spinlock on Win32,
+//  and a pthread_mutex otherwise.
+//
+//  Note that a spinlock is not a general synchronization primitive. In particular,
+//  it is not guaranteed to be a memory barrier, and it is possible to "livelock"
+//  if a lower-priority thread has acquired the spinlock but a higher-priority
+//  thread is spinning trying to acquire the same lock.
+//
+//  For these reasons, spinlocks have been disabled by default except on Windows,
+//  where a spinlock can be several orders of magnitude faster than a CRITICAL_SECTION.
+
+
+//  Note: lwm_linux.hpp has been disabled by default; see the comments
+//        inside for more info.
+
+
+#include <boost/config.hpp>
+
+//  Note to implementors: if you write a platform-specific spinlock
+//  for a platform that supports pthreads, be sure to test its performance
+//  against the pthreads-based version using shared_ptr_timing_test.cpp and
+//  shared_ptr_mt_test.cpp. Custom versions are usually not worth the trouble
+//  _unless_ the performance gains are substantial.
+//
+//  Be sure to compare against a "real" pthreads library;
+//  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>
+#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__)
+#  include <boost/detail/lwm_win32.hpp>
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi)
+#  include <boost/detail/lwm_irix.hpp>
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__)
+#  include <boost/detail/lwm_gcc.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+#  define BOOST_LWM_USE_PTHREADS
+#  include <boost/detail/lwm_pthreads.hpp>
+#else
+#  include <boost/detail/lwm_nop.hpp>
+#endif
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
--- a/include/boost/detail/lwm_gcc.hpp
+++ b/include/boost/detail/lwm_gcc.hpp
@@ -0,0 +1,78 @@
+#ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
+
+//
+//  boost/detail/lwm_gcc.hpp
+//
+//  lightweight_mutex for GNU libstdc++ v3
+//
+//  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
+//
+//  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.
+//
+
+#include <bits/atomicity.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    _Atomic_word a_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): a_(1)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( !__exchange_and_add(&m_.a_, -1) )
+            {
+                __atomic_add(&m_.a_, 1);
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            __atomic_add(&m_.a_, 1);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
--- a/include/boost/detail/lwm_irix.hpp
+++ b/include/boost/detail/lwm_irix.hpp
@@ -0,0 +1,78 @@
+#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.
+//
+
+#include <sgidefs.h>
+#include <mutex.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    __uint32_t 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:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( test_and_set32(&m_.l_, 1) )
+            {
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            m_.l_ = 0;
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
--- a/include/boost/detail/lwm_linux.hpp
+++ b/include/boost/detail/lwm_linux.hpp
@@ -0,0 +1,89 @@
+#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.
+//
+
+//
+//  This implementation uses <asm/atomic.h>. This is a kernel header;
+//  using kernel headers in a user program may cause a number of problems,
+//  and not all flavors of Linux provide the atomic instructions.
+//
+//  This file is only provided because the performance of this implementation
+//  is about 3.5 times higher than the pthreads version. Use at your own risk
+//  (by defining BOOST_USE_ASM_ATOMIC_H.)
+//
+
+#include <asm/atomic.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    atomic_t a_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex()
+    {
+        atomic_t a = ATOMIC_INIT(1);
+        a_ = a;
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( !atomic_dec_and_test(&m_.a_) )
+            {
+                atomic_inc(&m_.a_);
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            atomic_inc(&m_.a_);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
--- a/include/boost/detail/lwm_nop.hpp
+++ b/include/boost/detail/lwm_nop.hpp
@@ -0,0 +1,36 @@
+#ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/lwm_nop.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.
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+public:
+
+    typedef lightweight_mutex scoped_lock;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
--- a/include/boost/detail/lwm_pthreads.hpp
+++ b/include/boost/detail/lwm_pthreads.hpp
@@ -0,0 +1,85 @@
+#ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/lwm_pthreads.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.
+//
+
+#include <pthread.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    pthread_mutex_t m_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex()
+    {
+
+// HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
+
+#if defined(__hpux) && defined(_DECTHREADS_)
+        pthread_mutex_init(&m_, pthread_mutexattr_default);
+#else
+        pthread_mutex_init(&m_, 0);
+#endif
+    }
+
+    ~lightweight_mutex()
+    {
+        pthread_mutex_destroy(&m_);
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        pthread_mutex_t & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        scoped_lock(lightweight_mutex & m): m_(m.m_)
+        {
+            pthread_mutex_lock(&m_);
+        }
+
+        ~scoped_lock()
+        {
+            pthread_mutex_unlock(&m_);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
--- a/include/boost/detail/lwm_win32.hpp
+++ b/include/boost/detail/lwm_win32.hpp
@@ -0,0 +1,94 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/lwm_win32.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.
+//
+
+#include <boost/detail/winapi.hpp>
+
+#ifdef __BORLANDC__
+# pragma warn -8027     // Functions containing while are not expanded inline
+#endif
+
+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:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( winapi::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);
+            }
+        }
+
+        ~scoped_lock()
+        {
+            winapi::InterlockedExchange(&m_.l_, 0);
+
+            // Note: adding a yield here will make
+            // the spinlock more fair and will increase the overall
+            // performance of some applications substantially in
+            // high contention situations, but will penalize the
+            // low contention / single thread case up to 5x
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#ifdef __BORLANDC__
+# pragma warn .8027     // Functions containing while are not expanded inline
+#endif
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
--- a/include/boost/detail/lwm_win32_cs.hpp
+++ b/include/boost/detail/lwm_win32_cs.hpp
@@ -0,0 +1,78 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  boost/detail/lwm_win32_cs.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.
+//
+
+#include <boost/detail/winapi.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    winapi::critical_section cs_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex()
+    {
+        winapi::InitializeCriticalSection(&cs_);
+    }
+
+    ~lightweight_mutex()
+    {
+        winapi::DeleteCriticalSection(&cs_);
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            winapi::EnterCriticalSection(&m_.cs_);
+        }
+
+        ~scoped_lock()
+        {
+            winapi::LeaveCriticalSection(&m_.cs_);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
--- a/include/boost/detail/shared_array_nmt.hpp
+++ b/include/boost/detail/shared_array_nmt.hpp
@@ -0,0 +1,152 @@
+#ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+
+//
+//  detail/shared_array_nmt.hpp - shared_array.hpp without member templates
+//
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/atomic_count.hpp>
+
+#include <cstddef>          // for std::ptrdiff_t
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_array
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+      
+    explicit shared_array(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_array_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_array_delete(p);
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_array()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_array_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_array(shared_array const & r) : px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_array & operator=(shared_array const & r)
+    {
+        shared_array(r).swap(*this);
+        return *this;
+    }
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_array(p).swap(*this);
+    }
+
+    T * get() const  // never throws
+    {
+        return px;
+    }
+
+    T & operator[](std::ptrdiff_t i) const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        BOOST_ASSERT(i >= 0);
+        return px[i];
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+
+    void swap(shared_array<T> & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+      
+};  // shared_array
+
+template<class T, class U> inline bool operator==(shared_array<T> const & a, shared_array<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_array<T> const & a, shared_array<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
+{
+    a.swap(b);
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
--- a/include/boost/detail/shared_count.hpp
+++ b/include/boost/detail/shared_count.hpp
@@ -0,0 +1,445 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  detail/shared_count.hpp
+//
+//  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.
+//
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>
+#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
+
+#ifdef __BORLANDC__
+# pragma warn -8026     // Functions with excep. spec. are not expanded inline
+# pragma warn -8027     // Functions containing try are not expanded inline
+#endif
+
+namespace boost
+{
+
+// 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
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option push -pc
+#endif
+
+class use_count_is_zero: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "boost::use_count_is_zero";
+    }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
+class counted_base
+{
+private:
+
+    typedef detail::lightweight_mutex mutex_type;
+
+public:
+
+    counted_base():
+        use_count_(0), weak_count_(0)
+    {
+    }
+
+    // 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
+    {
+    }
+
+    // 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
+    {
+    }
+
+    // destruct() is called when weak_count_ drops to zero.
+
+    virtual void destruct() // nothrow
+    {
+        delete this;
+    }
+
+    void add_ref()
+    {
+#ifdef 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 release() // nothrow
+    {
+        long new_use_count;
+        long new_weak_count;
+
+        {
+#ifdef BOOST_HAS_THREADS
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            new_use_count = --use_count_;
+            new_weak_count = --weak_count_;
+        }
+
+        if(new_use_count == 0)
+        {
+            dispose();
+        }
+
+        if(new_weak_count == 0)
+        {
+            destruct();
+        }
+    }
+
+    void weak_add_ref() // nothrow
+    {
+#ifdef BOOST_HAS_THREADS
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++weak_count_;
+    }
+
+    void weak_release() // nothrow
+    {
+        long new_weak_count;
+
+        {
+#ifdef BOOST_HAS_THREADS
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            new_weak_count = --weak_count_;
+        }
+
+        if(new_weak_count == 0)
+        {
+            destruct();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+#ifdef BOOST_HAS_THREADS
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        return use_count_;
+    }
+
+private:
+
+    counted_base(counted_base const &);
+    counted_base & operator= (counted_base const &);
+
+    // inv: use_count_ <= weak_count_
+
+    long use_count_;
+    long weak_count_;
+
+#ifdef BOOST_HAS_THREADS
+    mutable mutex_type mtx_;
+#endif
+};
+
+inline void intrusive_ptr_add_ref(counted_base * p)
+{
+    p->add_ref();
+}
+
+inline void intrusive_ptr_release(counted_base * p)
+{
+    p->release();
+}
+
+namespace detail
+{
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+#pragma option push -Vx-
+#endif
+
+template<class P, class D> class counted_base_impl: public 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 &);
+
+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)
+    {
+    }
+
+    virtual void dispose() // nothrow
+    {
+        del(ptr);
+    }
+};
+
+class weak_count;
+
+class shared_count
+{
+private:
+
+    counted_base * pi_;
+
+    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))
+    {
+    }
+
+    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)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
+        }
+        catch(...)
+        {
+            d(p); // delete p
+            throw;
+        }
+
+#else
+
+        pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
+
+        if(pi_ == 0)
+        {
+            d(p); // delete p
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#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))
+    {
+        r.release();
+    }
+
+#endif 
+
+    ~shared_count() // nothrow
+    {
+        pi_->release();
+    }
+
+    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+    {
+        pi_->add_ref();
+    }
+
+    explicit shared_count(weak_count const & r); // throws use_count_is_zero 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;
+
+        return *this;
+    }
+
+    void swap(shared_count & r) // nothrow
+    {
+        counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_->use_count();
+    }
+
+    bool unique() const // nothrow
+    {
+        return pi_->use_count() == 1;
+    }
+
+    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    {
+        return std::less<counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+#ifdef __CODEGUARD__
+#pragma option pop
+#endif
+
+
+class weak_count
+{
+private:
+
+    counted_base * pi_;
+
+    friend class shared_count;
+
+public:
+
+    weak_count(): pi_(new counted_base(0, 1)) // can throw
+    {
+    }
+
+    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+    {
+        pi_->weak_add_ref();
+    }
+
+    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+    {
+        pi_->weak_add_ref();
+    }
+
+    ~weak_count() // nothrow
+    {
+        pi_->weak_release();
+    }
+
+    weak_count & operator= (shared_count const & r) // nothrow
+    {
+        counted_base * tmp = r.pi_;
+        tmp->weak_add_ref();
+        pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    weak_count & operator= (weak_count const & r) // nothrow
+    {
+        counted_base * tmp = r.pi_;
+        tmp->weak_add_ref();
+        pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    void swap(weak_count & r) // nothrow
+    {
+        counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_->use_count();
+    }
+
+    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    {
+        return std::less<counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+{
+    pi_->add_ref();
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#ifdef __BORLANDC__
+# pragma warn .8027     // Functions containing try are not expanded inline
+# pragma warn .8026     // Functions with excep. spec. are not expanded inline
+#endif
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
--- a/include/boost/detail/shared_ptr_nmt.hpp
+++ b/include/boost/detail/shared_ptr_nmt.hpp
@@ -0,0 +1,183 @@
+#ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+
+//
+//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
+//
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/atomic_count.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>          // for std::auto_ptr
+#endif
+
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_ptr
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+
+    explicit shared_ptr(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_delete(p);
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_ptr()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_ptr & operator=(shared_ptr const & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    explicit shared_ptr(std::auto_ptr<T> & r)
+    { 
+        pn = new count_type(1); // may throw
+        px = r.release(); // fix: moved here to stop leak if new throws
+    } 
+
+    shared_ptr & operator=(std::auto_ptr<T> & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_ptr(p).swap(*this);
+    }
+
+    T & operator*() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator->() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+
+    T * get() const  // never throws
+    {
+        return px;
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+    
+    void swap(shared_ptr<T> & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+};
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
--- a/include/boost/detail/winapi.hpp
+++ b/include/boost/detail/winapi.hpp
@@ -0,0 +1,106 @@
+#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/intrusive_ptr.hpp
+++ b/include/boost/intrusive_ptr.hpp
@@ -0,0 +1,202 @@
+#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+#define BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+
+//
+//  intrusive_ptr.hpp
+//
+//  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.
+//
+//  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
+//
+
+#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
+
+namespace boost
+{
+
+//
+//  intrusive_ptr
+//
+//  A smart pointer that uses intrusive reference counting.
+//
+//  Relies on unqualified calls to
+//  
+//      void intrusive_ptr_add_ref(T * p);
+//      void intrusive_ptr_release(T * p);
+//
+//          (p != 0)
+//
+//  The object is responsible for destroying itself.
+//
+
+template<class T> class intrusive_ptr
+{
+private:
+
+    typedef intrusive_ptr this_type;
+
+public:
+
+    intrusive_ptr(): p_(0)
+    {
+    }
+
+    intrusive_ptr(T * p): p_(p)
+    {
+        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(intrusive_ptr<U> const & rhs): p_(rhs.get())
+    {
+        if(p_ != 0) intrusive_ptr_add_ref(p_);
+    }
+
+#endif
+
+    intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_)
+    {
+        if(p_ != 0) intrusive_ptr_add_ref(p_);
+    }
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
+    {
+        this_type(rhs).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    intrusive_ptr & operator=(intrusive_ptr const & rhs)
+    {
+        this_type(rhs).swap(*this);
+        return *this;
+    }
+
+    intrusive_ptr & operator=(T * rhs)
+    {
+        this_type(rhs).swap(*this);
+        return *this;
+    }
+
+    void swap(intrusive_ptr & rhs)
+    {
+        T * tmp = p_;
+        p_ = rhs.p_;
+        rhs.p_ = tmp;
+    }
+
+    T * get() const
+    {
+        return p_;
+    }
+
+    T & operator*() const
+    {
+        return *p_;
+    }
+
+    T * operator->() const
+    {
+        return p_;
+    }
+
+    bool empty() const
+    {
+        return p_ == 0;
+    }
+
+    typedef bool (intrusive_ptr::*bool_type) () const;
+
+    operator bool_type () const
+    {
+        return p_ == 0? 0: &intrusive_ptr::empty;
+    }
+
+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();
+}
+
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+{
+    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;
+}
+
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, T * b)
+{
+    return a.get() != b;
+}
+
+template<class T> inline bool operator==(T * a, intrusive_ptr<T> const & b)
+{
+    return a == b.get();
+}
+
+template<class T> inline bool operator!=(T * a, intrusive_ptr<T> const & b)
+{
+    return a != b.get();
+}
+
+// mem_fn support
+
+template<class T> T * get_pointer(intrusive_ptr<T> const & p)
+{
+    return p.get();
+}
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
+#endif  // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
--- a/include/boost/scoped_array.hpp
+++ b/include/boost/scoped_array.hpp
@@ -0,0 +1,102 @@
+#ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
+#define BOOST_SCOPED_ARRAY_HPP_INCLUDED
+
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/scoped_array.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/config.hpp>   // in case ptrdiff_t not in std
+#include <cstddef>            // for std::ptrdiff_t
+
+namespace boost
+{
+
+//  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
+{
+private:
+
+    T * ptr;
+
+    scoped_array(scoped_array const &);
+    scoped_array & operator=(scoped_array const &);
+
+    typedef scoped_array<T> this_type;
+
+public:
+
+    typedef T element_type;
+
+    explicit scoped_array(T * p = 0) : ptr(p) // never throws
+    {
+    }
+
+    ~scoped_array() // never throws
+    {
+        checked_array_delete(ptr);
+    }
+
+    void reset(T * p = 0) // never throws
+    {
+        if (ptr != p)
+        {
+            checked_array_delete(ptr);
+            ptr = p;
+        }
+    }
+
+    T & operator[](std::ptrdiff_t i) const // never throws
+    {
+        BOOST_ASSERT(ptr != 0);
+        BOOST_ASSERT(i >= 0);
+        return ptr[i];
+    }
+
+    T * get() const // never throws
+    {
+        return ptr;
+    }
+
+    // implicit conversion to "bool"
+
+    typedef T * (this_type::*unspecified_bool_type)() const;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return ptr == 0? 0: &this_type::get;
+    }
+
+    bool operator! () const // never throws
+    {
+        return ptr == 0;
+    }
+
+    void swap(scoped_array & b) // never throws
+    {
+        T * tmp = b.ptr;
+        b.ptr = ptr;
+        ptr = tmp;
+    }
+
+};
+
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
+{
+    a.swap(b);
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
--- a/include/boost/scoped_ptr.hpp
+++ b/include/boost/scoped_ptr.hpp
@@ -0,0 +1,123 @@
+#ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
+#define BOOST_SCOPED_PTR_HPP_INCLUDED
+
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>          // for std::auto_ptr
+#endif
+
+namespace boost
+{
+
+//  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
+{
+private:
+
+    T * ptr;
+
+    scoped_ptr(scoped_ptr const &);
+    scoped_ptr & operator=(scoped_ptr const &);
+
+    typedef scoped_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+
+    explicit scoped_ptr(T * p = 0): ptr(p) // never throws
+    {
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release()) // never throws
+    {
+    }
+
+#endif
+
+    ~scoped_ptr() // never throws
+    {
+        checked_delete(ptr);
+    }
+
+    void reset(T * p = 0) // never throws
+    {
+        if(ptr != p)
+        {
+            this_type(p).swap(*this);
+        }
+    }
+
+    T & operator*() const // never throws
+    {
+        BOOST_ASSERT(ptr != 0);
+        return *ptr;
+    }
+
+    T * operator->() const // never throws
+    {
+        BOOST_ASSERT(ptr != 0);
+        return ptr;
+    }
+
+    T * get() const // never throws
+    {
+        return ptr;
+    }
+
+    // implicit conversion to "bool"
+
+    typedef T * (this_type::*unspecified_bool_type)() const;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return ptr == 0? 0: &this_type::get;
+    }
+
+    bool operator! () const // never throws
+    {
+        return ptr == 0;
+    }
+
+    void swap(scoped_ptr & b) // never throws
+    {
+        T * tmp = b.ptr;
+        b.ptr = ptr;
+        ptr = tmp;
+    }
+};
+
+template<typename 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)
+{
+    return p.get();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
--- a/include/boost/shared_array.hpp
+++ b/include/boost/shared_array.hpp
@@ -0,0 +1,156 @@
+#ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
+#define BOOST_SHARED_ARRAY_HPP_INCLUDED
+
+//
+//  shared_array.hpp
+//
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
+//
+
+#include <boost/config.hpp>   // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/detail/shared_array_nmt.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+
+#include <boost/detail/shared_count.hpp>
+
+#include <cstddef>            // for std::ptrdiff_t
+#include <algorithm>          // for std::swap
+#include <functional>         // for std::less
+
+namespace boost
+{
+
+//
+//  shared_array
+//
+//  shared_array extends shared_ptr to arrays.
+//  The array pointed to is deleted when the last shared_array pointing to it
+//  is destroyed or reset.
+//
+
+template<typename T> class shared_array
+{
+private:
+
+    // Borland 5.5.1 specific workarounds
+    typedef checked_array_deleter<T> deleter;
+    typedef shared_array<T> this_type;
+
+public:
+
+    typedef T element_type;
+
+    explicit shared_array(T * p = 0): px(p), pn(p, deleter())
+    {
+    }
+
+    //
+    // Requirements: D's copy constructor must not throw
+    //
+    // shared_array will release p by calling d(p)
+    //
+
+    template<typename D> shared_array(T * p, D d): px(p), pn(p, d)
+    {
+    }
+
+//  generated copy constructor, assignment, destructor are fine
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        this_type(p).swap(*this);
+    }
+
+    template <typename D> void reset(T * p, D d)
+    {
+        this_type(p, d).swap(*this);
+    }
+
+    T & operator[] (std::ptrdiff_t i) const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        BOOST_ASSERT(i >= 0);
+        return px[i];
+    }
+    
+    T * get() const // never throws
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+
+    typedef T * (this_type::*unspecified_bool_type)() const;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::get;
+    }
+
+    bool operator! () const // never throws
+    {
+        return px == 0;
+    }
+
+    bool unique() const // never throws
+    {
+        return pn.unique();
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    void swap(shared_array<T> & other) // never throws
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+private:
+
+    T * px;                     // contained pointer
+    detail::shared_count pn;    // reference counter
+
+};  // shared_array
+
+template<typename 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
+{
+    return a.get() != b.get();
+}
+
+template<typename 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
+{
+    a.swap(b);
+}
+
+} // namespace boost
+
+#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+#endif  // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
--- a/include/boost/shared_ptr.hpp
+++ b/include/boost/shared_ptr.hpp
@@ -0,0 +1,356 @@
+#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SHARED_PTR_HPP_INCLUDED
+
+//
+//  shared_ptr.hpp
+//
+//  (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.
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/config.hpp>   // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/detail/shared_ptr_nmt.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/shared_count.hpp>
+
+#include <memory>             // for std::auto_ptr
+#include <algorithm>          // for std::swap
+#include <functional>         // for std::less
+#include <typeinfo>           // for std::bad_cast
+
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+struct static_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+
+template<typename T> struct shared_ptr_traits
+{
+    typedef T & reference;
+};
+
+template<> struct shared_ptr_traits<void>
+{
+    typedef void reference;
+};
+
+#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+
+template<> struct shared_ptr_traits<void const>
+{
+    typedef void reference;
+};
+
+#endif
+
+} // namespace detail
+
+
+//
+//  shared_ptr
+//
+//  An enhanced relative of scoped_ptr with reference counted copy semantics.
+//  The object pointed to is deleted when the last shared_ptr pointing to it
+//  is destroyed or reset.
+//
+
+template<typename T> class weak_ptr;
+template<typename T> class intrusive_ptr;
+
+template<typename T> class shared_ptr
+{
+private:
+
+    // Borland 5.5.1 specific workarounds
+//  typedef checked_deleter<T> deleter;
+    typedef shared_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+
+    shared_ptr(): px(0), pn()
+    {
+    }
+
+    template<typename Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
+    {
+    }
+
+    //
+    // Requirements: D's copy constructor must not throw
+    //
+    // 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)
+    {
+    }
+
+//  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
+    {
+    }
+
+    template<typename 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>
+    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<typename 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
+        {
+            pn = detail::shared_count();
+        }
+    }
+
+    template<typename 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)
+        {
+            boost::throw_exception(std::bad_cast());
+        }
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<typename Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
+    {
+    }
+
+#endif
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+    template<typename Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+
+#endif
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<typename Y>
+    shared_ptr & operator=(std::auto_ptr<Y> & r)
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset()
+    {
+        this_type().swap(*this);
+    }
+
+    template<typename 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)
+    {
+        this_type(p, d).swap(*this);
+    }
+
+    typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator-> () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+    
+    T * get() const // never throws
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+
+    typedef T * (this_type::*unspecified_bool_type)() const;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::get;
+    }
+
+    bool operator! () const // never throws
+    {
+        return px == 0;
+    }
+
+    bool unique() const // never throws
+    {
+        return pn.unique();
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    void swap(shared_ptr<T> & other) // never throws
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+    template<typename Y> friend class shared_ptr;
+    template<typename Y> friend class weak_ptr;
+
+
+#endif
+
+    T * px;                     // contained pointer
+    detail::shared_count pn;    // reference counter
+
+};  // shared_ptr
+
+template<typename T, typename 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)
+{
+    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!=(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)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<typename 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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
+    return shared_static_cast<T>(r);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<typename 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')
+
+namespace detail
+{
+
+inline void sp_assert_counted_base(boost::counted_base const *)
+{
+}
+
+template<class T> inline T * sp_remove_const(T const * p)
+{
+    return const_cast<T *>(p);
+}
+
+} // namespace detail
+
+template<class T> shared_ptr<T> shared_from_this(T * p)
+{
+    detail::sp_assert_counted_base(p);
+    return shared_ptr<T>(detail::sp_remove_const(p));
+}
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
+#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+#endif  // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
--- a/include/boost/smart_ptr.hpp
+++ b/include/boost/smart_ptr.hpp
@@ -1,402 +1,9 @@
 //  Boost smart_ptr.hpp header file  -----------------------------------------//

-//  (C) Copyright Greg Colvin and 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.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//   6 Jul 01  Reorder shared_ptr code so VC++ 6 member templates work, allowing
-//             polymorphic pointers to now work with that compiler (Gary Powell)
-//  21 May 01  Require complete type where incomplete type is unsafe.
-//             (suggested by Vladimir Prus)
-//  21 May 01  operator= fails if operand transitively owned by *this, as in a
-//             linked list (report by Ken Johnson, fix by Beman Dawes)
-//  21 Jan 01  Suppress some useless warnings with MSVC (David Abrahams)
-//  19 Oct 00  Make shared_ptr ctor from auto_ptr explicit. (Robert Vugts) 
-//  24 Jul 00  Change throw() to // never throws.  See lib guidelines
-//             Exception-specification rationale. (Beman Dawes)
-//  22 Jun 00  Remove #if continuations to fix GCC 2.95.2 problem (Beman Dawes)
-//   1 Feb 00  Additional shared_ptr BOOST_NO_MEMBER_TEMPLATES workarounds
-//             (Dave Abrahams)
-//  31 Dec 99  Condition tightened for no member template friend workaround
-//             (Dave Abrahams)
-//  30 Dec 99  Moved BOOST_NMEMBER_TEMPLATES compatibility code to config.hpp
-//             (Dave Abrahams)
-//  30 Nov 99  added operator ==, operator !=, and std::swap and std::less
-//             specializations for shared types (Darin Adler)
-//  11 Oct 99  replaced op[](int) with op[](std::size_t) (Ed Brey, Valentin
-//             Bonnard), added shared_ptr workaround for no member template
-//             friends (Matthew Langston)
-//  25 Sep 99  added shared_ptr::swap and shared_array::swap (Luis Coelho).
-//  20 Jul 99  changed name to smart_ptr.hpp, #include <boost/config.hpp>,
-//             #include <boost/utility.hpp> and use boost::noncopyable
-//  17 May 99  remove scoped_array and shared_array operator*() as
-//             unnecessary (Beman Dawes)
-//  14 May 99  reorder code so no effects when bad_alloc thrown (Abrahams/Dawes)
-//  13 May 99  remove certain throw() specifiers to avoid generated try/catch
-//             code cost (Beman Dawes)
-//  11 May 99  get() added, conversion to T* placed in macro guard (Valentin
-//             Bonnard, Dave Abrahams, and others argued for elimination
-//             of the automatic conversion)
-//  28 Apr 99  #include <memory> fix (Valentin Bonnard)
-//  28 Apr 99  rename transfer() to share() for clarity (Dave Abrahams)
-//  28 Apr 99  remove unsafe shared_array template conversions(Valentin Bonnard)
-//  28 Apr 99  p(r) changed to p(r.px) for clarity (Dave Abrahams)
-//  21 Apr 99  reset() self assignment fix (Valentin Bonnard)
-//  21 Apr 99  dispose() provided to improve clarity (Valentin Bonnard)
-//  27 Apr 99  leak when new throws fixes (Dave Abrahams)
-//  21 Oct 98  initial Version (Greg Colvin/Beman Dawes)
-
-#ifndef BOOST_SMART_PTR_HPP
-#define BOOST_SMART_PTR_HPP
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-#include <cstddef>            // for std::size_t
-#include <memory>             // for std::auto_ptr
-#include <algorithm>          // for std::swap
-#include <boost/utility.hpp>  // for boost::noncopyable, checked_delete, checked_array_delete
-#include <functional>         // for std::less
-#include <boost/static_assert.hpp> // for BOOST_STATIC_ASSERT
-
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // return type for 'identifier::operator->' is not a UDT or reference to a UDT. Will produce errors if applied using infix notation
-#endif    
-
-namespace boost {
-
-//  scoped_ptr  --------------------------------------------------------------//
-
-//  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;
-//  see shared_ptr (below) or std::auto_ptr if your needs are more complex.
-
-template<typename T> class scoped_ptr : noncopyable {
-
-  T* ptr;
-
- public:
-  typedef T element_type;
-
-  explicit scoped_ptr( T* p=0 ) : ptr(p) {}  // never throws
-  ~scoped_ptr()                 { checked_delete(ptr); }
-  void reset( T* p=0 )          { if ( ptr != p ) { checked_delete(ptr); ptr = p; } }
-  T& operator*() const          { return *ptr; }  // never throws
-  T* operator->() const         { return ptr; }  // never throws
-  T* get() const                { return ptr; }  // never throws
-#ifdef BOOST_SMART_PTR_CONVERSION
-  // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-  operator T*() const           { return ptr; }  // never throws 
-#endif
-  };  // scoped_ptr
-
-//  scoped_array  ------------------------------------------------------------//
-
-//  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(). See shared_array or std::vector if your needs are more complex.
-
-template<typename T> class scoped_array : noncopyable {
-
-  T* ptr;
-
- public:
-  typedef T element_type;
-
-  explicit scoped_array( T* p=0 ) : ptr(p) {}  // never throws
-  ~scoped_array()                    { checked_array_delete(ptr); }
-
-  void reset( T* p=0 )               { if ( ptr != p )
-                                         {checked_array_delete(ptr); ptr=p;} }
-
-  T* get() const                     { return ptr; }  // never throws
-#ifdef BOOST_SMART_PTR_CONVERSION
-  // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-  operator T*() const                { return ptr; }  // never throws
-#else 
-  T& operator[](std::size_t i) const { return ptr[i]; }  // never throws
-#endif
-  };  // scoped_array
-
-//  shared_ptr  --------------------------------------------------------------//
-
-//  An enhanced relative of scoped_ptr with reference counted copy semantics.
-//  The object pointed to is deleted when the last shared_ptr pointing to it
-//  is destroyed or reset.
-
-template<typename T> class shared_ptr {
-  public:
-   typedef T element_type;
-
-   explicit shared_ptr(T* p =0) : px(p) {
-      try { pn = new long(1); }  // fix: prevent leak if new throws
-      catch (...) { checked_delete(p); throw; } 
-   }
-
-   ~shared_ptr() { dispose(); }
-
-#if !defined( BOOST_NO_MEMBER_TEMPLATES ) || defined (BOOST_MSVC6_MEMBER_TEMPLATES)
-   template<typename Y>
-      shared_ptr(const shared_ptr<Y>& r) : px(r.px) {  // never throws 
-         ++*(pn = r.pn); 
-      }
-#ifndef BOOST_NO_AUTO_PTR
-   template<typename Y>
-      explicit shared_ptr(std::auto_ptr<Y>& r) { 
-         pn = new long(1); // may throw
-         px = r.release(); // fix: moved here to stop leak if new throws
-      }
-#endif 
-
-   template<typename Y>
-      shared_ptr& operator=(const shared_ptr<Y>& r) { 
-         share(r.px,r.pn);
-         return *this;
-      }
-
-#ifndef BOOST_NO_AUTO_PTR
-   template<typename Y>
-      shared_ptr& operator=(std::auto_ptr<Y>& r) {
-         // code choice driven by guarantee of "no effect if new throws"
-         if (*pn == 1) { checked_delete(px); }
-         else { // allocate new reference counter
-           long * tmp = new long(1); // may throw
-           --*pn; // only decrement once danger of new throwing is past
-           pn = tmp;
-         } // allocate new reference counter
-         px = r.release(); // fix: moved here so doesn't leak if new throws 
-         return *this;
-      }
-#endif
-#else
-#ifndef BOOST_NO_AUTO_PTR
-      explicit shared_ptr(std::auto_ptr<T>& r) { 
-         pn = new long(1); // may throw
-         px = r.release(); // fix: moved here to stop leak if new throws
-      } 
-
-      shared_ptr& operator=(std::auto_ptr<T>& r) {
-         // code choice driven by guarantee of "no effect if new throws"
-         if (*pn == 1) { checked_delete(px); }
-         else { // allocate new reference counter
-           long * tmp = new long(1); // may throw
-           --*pn; // only decrement once danger of new throwing is past
-           pn = tmp;
-         } // allocate new reference counter
-         px = r.release(); // fix: moved here so doesn't leak if new throws 
-         return *this;
-      }
-#endif
-#endif
-
-   // The assignment operator and the copy constructor must come after
-   // the templated versions for MSVC6 to work. (Gary Powell)
-   shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); }  // never throws
-
-   shared_ptr& operator=(const shared_ptr& r) {
-      share(r.px,r.pn);
-      return *this;
-   }
-
-   void reset(T* p=0) {
-      if ( px == p ) return;  // fix: self-assignment safe
-      if (--*pn == 0) { checked_delete(px); }
-      else { // allocate new reference counter
-        try { pn = new long; }  // fix: prevent leak if new throws
-        catch (...) {
-          ++*pn;  // undo effect of --*pn above to meet effects guarantee 
-          checked_delete(p);
-          throw;
-        } // catch
-      } // allocate new reference counter
-      *pn = 1;
-      px = p;
-   } // reset
-
-   T& operator*() const          { return *px; }  // never throws
-   T* operator->() const         { return px; }  // never throws
-   T* get() const                { return px; }  // never throws
- #ifdef BOOST_SMART_PTR_CONVERSION
-   // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-   operator T*() const           { return px; }  // never throws 
- #endif
-
-   long use_count() const        { return *pn; }  // never throws
-   bool unique() const           { return *pn == 1; }  // never throws
-
-   void swap(shared_ptr<T>& other)  // never throws
-     { std::swap(px,other.px); std::swap(pn,other.pn); }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
-#if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
-   private:
-#endif
-
-   T*     px;     // contained pointer
-   long*  pn;     // ptr to reference counter
-
-// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
-#if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
-   template<typename Y> friend class shared_ptr;
-#endif
-
-   void dispose() { if (--*pn == 0) { checked_delete(px); delete pn; } }
-
-   void share(T* rpx, long* rpn) {
-      if (pn != rpn) { // Q: why not px != rpx? A: fails when both == 0
-         ++*rpn; // done before dispose() in case rpn transitively
-                 // dependent on *this (bug reported by Ken Johnson)
-         dispose();
-         px = rpx;
-         pn = rpn;
-      }
-   } // share
-};  // shared_ptr
-
-template<typename T, typename U>
-  inline bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b)
-    { return a.get() == b.get(); }
-
-template<typename T, typename U>
-  inline bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b)
-    { return a.get() != b.get(); }
-
-//  shared_array  ------------------------------------------------------------//
-
-//  shared_array extends shared_ptr to arrays.
-//  The array pointed to is deleted when the last shared_array pointing to it
-//  is destroyed or reset.
-
-template<typename T> class shared_array {
-  public:
-   typedef T element_type;
-
-   explicit shared_array(T* p =0) : px(p) {
-      try { pn = new long(1); }  // fix: prevent leak if new throws
-      catch (...) { checked_array_delete(p); throw; } 
-   }
-
-   shared_array(const shared_array& r) : px(r.px)  // never throws
-      { ++*(pn = r.pn); }
-
-   ~shared_array() { dispose(); }
-
-   shared_array& operator=(const shared_array& r) {
-      if (pn != r.pn) { // Q: why not px != r.px? A: fails when both px == 0
-         ++*r.pn; // done before dispose() in case r.pn transitively
-                  // dependent on *this (bug reported by Ken Johnson)
-         dispose();
-         px = r.px;
-         pn = r.pn;
-      }
-      return *this;
-   } // operator=
-
-   void reset(T* p=0) {
-      if ( px == p ) return;  // fix: self-assignment safe
-      if (--*pn == 0) { checked_array_delete(px); }
-      else { // allocate new reference counter
-        try { pn = new long; }  // fix: prevent leak if new throws
-        catch (...) {
-          ++*pn;  // undo effect of --*pn above to meet effects guarantee 
-          checked_array_delete(p);
-          throw;
-        } // catch
-      } // allocate new reference counter
-      *pn = 1;
-      px = p;
-   } // reset
-
-   T* get() const                     { return px; }  // never throws
- #ifdef BOOST_SMART_PTR_CONVERSION
-   // get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
-   operator T*() const                { return px; }  // never throws
- #else 
-   T& operator[](std::size_t i) const { return px[i]; }  // never throws
- #endif
-
-   long use_count() const             { return *pn; }  // never throws
-   bool unique() const                { return *pn == 1; }  // never throws
-
-   void swap(shared_array<T>& other)  // never throws
-     { std::swap(px,other.px); std::swap(pn,other.pn); }
-
-  private:
-
-   T*     px;     // contained pointer
-   long*  pn;     // ptr to reference counter
-
-   void dispose() { if (--*pn == 0) { checked_array_delete(px); delete pn; } }
-
-};  // shared_array
-
-template<typename T>
-  inline bool operator==(const shared_array<T>& a, const shared_array<T>& b)
-    { return a.get() == b.get(); }
-
-template<typename T>
-  inline bool operator!=(const shared_array<T>& a, const shared_array<T>& b)
-    { return a.get() != b.get(); }
-
-} // namespace boost
-
-//  specializations for things in namespace std  -----------------------------//
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace std {
-
-// Specialize std::swap to use the fast, non-throwing swap that's provided
-// as a member function instead of using the default algorithm which creates
-// a temporary and uses assignment.
-
-template<typename T>
-  inline void swap(boost::shared_ptr<T>& a, boost::shared_ptr<T>& b)
-    { a.swap(b); }
-
-template<typename T>
-  inline void swap(boost::shared_array<T>& a, boost::shared_array<T>& b)
-    { a.swap(b); }
-
-// Specialize std::less so we can use shared pointers and arrays as keys in
-// associative collections.
-
-// It's still a controversial question whether this is better than supplying
-// a full range of comparison operators (<, >, <=, >=).
-
-template<typename T>
-  struct less< boost::shared_ptr<T> >
-    : binary_function<boost::shared_ptr<T>, boost::shared_ptr<T>, bool>
-  {
-    bool operator()(const boost::shared_ptr<T>& a,
-        const boost::shared_ptr<T>& b) const
-      { return less<T*>()(a.get(),b.get()); }
-  };
-
-template<typename T>
-  struct less< boost::shared_array<T> >
-    : binary_function<boost::shared_array<T>, boost::shared_array<T>, bool>
-  {
-    bool operator()(const boost::shared_array<T>& a,
-        const boost::shared_array<T>& b) const
-      { return less<T*>()(a.get(),b.get()); }
-  };
-
-} // namespace std
-
-#endif  // ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
-#endif  // BOOST_SMART_PTR_HPP
-
+// For compatibility, this header includes the header for the four "classic"
+// smart pointer class templates.

+#include <boost/scoped_ptr.hpp> 
+#include <boost/scoped_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/shared_array.hpp>
--- a/include/boost/weak_ptr.hpp
+++ b/include/boost/weak_ptr.hpp
@@ -0,0 +1,181 @@
+#ifndef BOOST_WEAK_PTR_HPP_INCLUDED
+#define BOOST_WEAK_PTR_HPP_INCLUDED
+
+//
+//  weak_ptr.hpp
+//
+//  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.
+//
+//  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
+//
+
+#include <boost/shared_ptr.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
+
+namespace boost
+{
+
+template<typename T> class weak_ptr
+{
+private:
+
+    // Borland 5.5.1 specific workarounds
+    typedef weak_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+
+    weak_ptr(): px(0), pn()
+    {
+    }
+
+//  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
+    {
+    }
+
+    template<typename 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>
+    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn;
+        return *this;
+    }
+
+    template<typename Y>
+    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn;
+        return *this;
+    }
+
+#endif
+
+    void reset()
+    {
+        this_type().swap(*this);
+    }
+
+    T * get() const // never throws; deprecated, removal pending, don't use
+    {
+        return pn.use_count() == 0? 0: px;
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    bool expired() const // never throws
+    {
+        return pn.use_count() == 0;
+    }
+
+    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
+    {
+        return pn < rhs.pn;
+    }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+    template<typename Y> friend class weak_ptr;
+    template<typename Y> friend class shared_ptr;
+
+#endif
+
+    T * px;                     // contained pointer
+    detail::weak_count pn;      // reference counter
+
+};  // weak_ptr
+
+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);
+}
+
+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
+{
+    // 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>();
+    }
+}
+
+// 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
+# pragma warning(pop)
+#endif    
+
+#endif  // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED
--- a/index.htm
+++ b/index.htm
@@ -1,10 +1,10 @@
+<!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>
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
 </head>

 <body bgcolor="#FFFFFF" text="#000000">
@@ -19,19 +19,28 @@
    <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 header smart_ptr.hpp provides four smart pointer classes.&nbsp; Smart
-pointers ease the management of memory dynamically allocated with C++ <strong>new</strong>
-expressions.
+<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/smart_ptr.hpp">smart_ptr.hpp</a></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>Submitted by <a href="../../people/greg_colvin.htm">Greg Colvin</a> and <a href="../../people/beman_dawes.html">Beman
-    Dawes</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 -->14 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14885" -->
-</p>
+
+<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>

--- a/scoped_array.htm
+++ b/scoped_array.htm
@@ -1,102 +1,111 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-
 	<head>
 		<title>scoped_array</title>
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
+		<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="center" width="277" height="86">Class
-<a name="scoped_array">scoped_array</a></h1>
-<p>Class <strong>scoped_array</strong> stores a pointer to a dynamically
-allocated array. (Dynamically allocated arrays are allocated with the C++ <tt>new[]</tt>
-expression.)&nbsp;&nbsp; The array pointed to is guaranteed to be deleted,
-either on destruction of the <strong>scoped_array</strong>, or via an explicit <strong>scoped_array::reset()</strong>.</p>
-<p>Class<strong> scoped_array</strong> is a simple solution for simple
-needs.&nbsp;It supplies a basic &quot;resource acquisition is
-initialization&quot; facility, without shared-ownership or transfer-of-ownership
-semantics.&nbsp; 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.&nbsp; By
-being <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 <strong>scoped_array</strong> is so simple, in its usual
-implementation every operation is as fast as a built-in array pointer and it has no
-more space overhead that a built-in array pointer.</p>
-<p>It cannot be used in C++ Standard Library containers.&nbsp; See <a href="shared_array.htm"><strong>shared_array</strong></a>
-if <strong>scoped_array</strong> does not meet your needs.</p>
-<p>Class<strong> scoped_array</strong> cannot correctly hold a pointer to a
-single object.&nbsp; See <a href="scoped_ptr.htm"><strong>scoped_ptr</strong></a>
+	<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>
+			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>
+			expression.) The array pointed to is guaranteed to be deleted, either on 
+			destruction of the <b>scoped_array</b>, or via an explicit <b>reset</b>.</p>
+		<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>, 
+			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 
+			overhead that a built-in array pointer.</p>
+		<p>It cannot be used in C++ standard library containers. See <a href="shared_array.htm">
+				<b>shared_array</b></a> if <b>scoped_array</b> does not meet your needs.</p>
+		<p>It cannot correctly hold a pointer to a single object. See <a href="scoped_ptr.htm"><b>scoped_ptr</b></a>
 			for that usage.</p>
-<p>A C++ Standard Library <strong>vector</strong> is a <strong> </strong>heavier duty alternative to a <strong>scoped_array</strong>.</p>
-<p>The class is a template parameterized on <tt>T</tt>, the type of the object
-pointed to.&nbsp;&nbsp; <tt>T</tt> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">common
-requirements</a>.</p>
-<h2>Class scoped_array Synopsis</h2>
-<pre>#include &lt;<a href="../../boost/smart_ptr.hpp">boost/smart_ptr.hpp</a>&gt;
-namespace boost {
+		<p>A <b>std::vector</b> is an alternative to a <b>scoped_array</b> that is a bit 
+			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">
+				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> {

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

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

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

-   T&amp; <a href="#scoped_array_operator[]">operator[]</a>(std::size_t i) const;  // never throws
-   T* <a href="#scoped_array_get">get</a>() const;  // never throws
+      T &amp; <a href="#operator[]">operator[]</a>(std::ptrdiff_t i) const; // never throws
+      T * <a href="#get">get</a>() const; // never throws
+     
+      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
+
 }</pre>
-<h2>Class scoped_array Members</h2>
-<h3>scoped_array <a name="scoped_array_element_type">element_type</a></h3>
+		<h2>Members</h2>
+		<h3>
+			<a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
 		<p>Provides the type of the stored pointer.</p>
-<h3><a name="scoped_array_ctor">scoped_array constructors</a></h3>
+		<h3><a name="ctor">constructors</a></h3>
 		<pre>explicit scoped_array(T * p = 0); // never throws</pre>
-<p>Constructs a <tt>scoped_array</tt>, storing a copy of <tt>p</tt>, which must
-have been allocated via a C++ <tt>new</tt>[] expression or be 0.</p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<h3><a name="scoped_array_~scoped_array">scoped_array destructor</a></h3>
-<pre>~scoped_array();</pre>
-<p>Deletes the array pointed to by the stored pointer.&nbsp; Note that in C++ <tt>delete</tt>[]
-on a pointer with a value of 0 is harmless.</p>
-<p>Does not throw exceptions.</p>
-<h3>scoped_array <a name="scoped_array_reset">reset</a></h3>
-<pre>void reset( T* p=0 )();</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">
+				common requirements</a>.</p>
+		<h3><a name="~scoped_array">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">
+				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++ <tt>new[]</tt> expression or be 0.</p>
-<p>Does not throw exceptions.</p>
-<h3>scoped_array <a name="scoped_array_operator[]">operator[]</a></h3>
-<p><tt>T&amp; operator[](std::size_t i) const; // never throws</tt></p>
-<p>Returns a reference to element <tt>i</tt> of the array pointed to by the
-stored pointer.</p>
-<p>Behavior is undefined (and almost certainly undesirable) if <tt>get()==0</tt>,
-or if <tt>i</tt> is less than 0 or is greater or equal to the number of elements
-in the array.</p>
-<h3>scoped_array <a name="scoped_array_get">get</a></h3>
+			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 
+			pointer. Behavior is undefined and almost certainly undesirable if the stored 
+			pointer is 0, or if <b>i</b> is less than 0 or is greater than or equal to the 
+			number of elements in the array.</p>
+		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns the stored pointer.</p>
-<h2>Class <a name="shared_array_example">scoped_array example</a></h2>
-<p>[To be supplied. In the meantime, see <a href="smart_ptr_test.cpp">smart_ptr_test.cpp</a>.]</p>
+		<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>
+		<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 
+				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>
+		<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&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->24 May, 2001<!--webbot bot="Timestamp" endspan i-checksum="13964"
-->
-</p>
-<p><EFBFBD> Copyright Greg Colvin and Beman Dawes 1999. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
-
+		<p>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>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>
--- a/scoped_ptr.htm
+++ b/scoped_ptr.htm
@@ -1,95 +1,112 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-
 	<head>
 		<title>scoped_ptr</title>
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
+		<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="center" width="277" height="86">Class
-<a name="scoped_ptr">scoped_ptr</a></h1>
-<p>Class <strong>scoped_ptr</strong> stores a pointer to a dynamically allocated
-object. (Dynamically allocated objects are allocated with the C++ <tt>new</tt>
-expression.)&nbsp;&nbsp; The object pointed to is guaranteed to be deleted,
-either on destruction of the <strong>scoped_ptr</strong>, or via an explicit <strong>scoped_ptr::reset()</strong>.&nbsp;
-See <a href="#scoped_ptr_example">example</a>.</p>
-<p>Class<strong> scoped_ptr</strong> is a simple solution for simple
-needs.&nbsp; It supplies a basic &quot;resource acquisition is
-initialization&quot; facility, without shared-ownership or transfer-of-ownership
-semantics.&nbsp; 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.&nbsp;
-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 <strong>scoped_ptr</strong> is so simple, in its usual implementation
-every operation is as fast as for a built-in pointer and it has no more space overhead
-that a built-in pointer.&nbsp; (Because of the &quot;complete type&quot;
-requirement for delete and reset members, they may have one additional function
-call overhead in certain idioms.&nbsp; See <a href="#Handle/Body">Handle/Body
-Idiom</a>.)&nbsp;&nbsp;&nbsp;</p>
-<p>Class<strong> scoped_ptr</strong> cannot be used in C++ Standard Library containers.&nbsp; See <a href="shared_ptr.htm"><strong>shared_ptr</strong></a>
-or std::auto_ptr if <strong>scoped_ptr</strong> does not meet your needs.</p>
-<p>Class<strong> scoped_ptr</strong> cannot correctly hold a pointer to a
-dynamically allocated array.&nbsp; See <a href="scoped_array.htm"><strong>scoped_array</strong></a>
-for that usage.</p>
-<p>The class is a template parameterized on <tt>T</tt>, the type of the object
-pointed to.&nbsp;&nbsp; <tt>T</tt> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">common
-requirements</a>.</p>
-<h2>Class scoped_ptr Synopsis</h2>
-<pre>#include &lt;<a href="../../boost/smart_ptr.hpp">boost/smart_ptr.hpp</a>&gt;
-namespace boost {
+	<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>
+			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.) 
+			The object pointed to is guaranteed to be deleted, either on destruction of the <b>scoped_ptr</b>, 
+			or via an explicit <b>reset</b>. See the <a href="#example">example</a>.</p>
+		<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">
+				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_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 
+			is as fast as for a built-in pointer and it has no more space overhead that a 
+			built-in pointer.</p>
+		<p><STRONG>scoped_ptr</STRONG> cannot be used in C++ Standard Library containers. 
+			Use <a href="shared_ptr.htm"><b>shared_ptr</b></a> if you need a smart pointer 
+			that can.</p>
+		<p><STRONG>scoped_ptr</STRONG> cannot correctly hold a pointer to a dynamically 
+			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">
+				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> {

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

-   explicit <a href="#scoped_ptr_ctor">scoped_ptr</a>( T* p=0 );  // never throws
-  <strong> </strong><a href="#scoped_ptr_~scoped_ptr">~scoped_ptr</a>();
+     explicit <a href="#constructors">scoped_ptr</a>(T * p = 0); // never throws
+     <a href="#destructor">~scoped_ptr</a>(); // never throws

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

-   T&amp; <a href="#scoped_ptr_operator*">operator*</a>() const;  // never throws
-   T* <a href="#scoped_ptr_operator-&gt;">operator-&gt;</a>() const;  // never throws
-   T* <a href="#scoped_ptr_get">get</a>() const;  // never throws
+     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
+     
+     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
+
 }</pre>
-<h2>Class scoped_ptr Members</h2>
-<h3>scoped_ptr <a name="scoped_ptr_element_type">element_type</a></h3>
+		<h2>Members</h2>
+		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
 		<p>Provides the type of the stored pointer.</p>
-<h3><a name="scoped_ptr_ctor">scoped_ptr constructors</a></h3>
+		<h3><a name="constructors">constructors</a></h3>
 		<pre>explicit scoped_ptr(T * p = 0); // never throws</pre>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Constructs a <tt>scoped_ptr</tt>, storing a copy of <tt>p</tt>, which must
-have been allocated via a C++ <tt>new</tt> expression or be 0.</p>
-<h3><a name="scoped_ptr_~scoped_ptr">scoped_ptr destructor</a></h3>
-<pre>~scoped_ptr();</pre>
-<p>Deletes the object pointed to by the stored pointer.&nbsp; Note that in C++, <tt>delete</tt>
-on a pointer with a value of 0 is harmless.</p>
-<p>Does not throw exceptions.</p>
-<h3>scoped_ptr <a name="scoped_ptr_reset">reset</a></h3>
-<pre>void reset( T* p=0 );</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 
+				requirements</a>.</p>
+		<h3><a name="destructor">destructor</a></h3>
+		<pre>~scoped_ptr(); // never throws</pre>
+		<p>Destroys the object pointed to by the stored pointer, if any, as if by using <tt>delete 
+				this-&gt;get()</tt>.</p>
+		<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>
+		<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++ <tt>new</tt> expression or be 0.</p>
-<p>Does not throw exceptions.</p>
-<h3>scoped_ptr <a name="scoped_ptr_operator*">operator*</a></h3>
+			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.</p>
-<h3>scoped_ptr <a name="scoped_ptr_operator-&gt;">operator-&gt;</a> and <a name="scoped_ptr_get">get</a></h3>
-<pre>T* operator-&gt;() const;  // never throws
-T* get() const;  // never throws</pre>
-<p><b>T</b> is not required by get() be a complete type.&nbsp; See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Both return the stored pointer.</p>
-<h2>Class <a name="scoped_ptr_example">scoped_ptr example</a>s</h2>
-<pre>#include &lt;iostream&gt;
-#include &lt;boost/smart_ptr.h&gt;
+		<p>Returns a reference to the object pointed to by the stored pointer. Behavior is 
+			undefined if the stored pointer is 0.</p>
+		<pre>T * operator-&gt;() const; // never throws</pre>
+		<p>Returns the stored pointer. Behavior is undefined if the stored pointer is 0.</p>
+		<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>
+		<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 
+				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>
+		<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>
+		<p>Here's an example that uses <b>scoped_ptr</b>.</p>
+		<blockquote>
+			<pre>#include &lt;boost/scoped_ptr.hpp&gt;
+#include &lt;iostream&gt;

-struct Shoe { ~Shoe(){ std::cout &lt;&lt; &quot;Buckle my shoe&quot; &lt;&lt; std::endl; } };
+struct Shoe { ~Shoe() { std::cout &lt;&lt; "Buckle my shoe\n"; } };

 class MyClass {
    boost::scoped_ptr&lt;int&gt; ptr;
@@ -98,56 +115,62 @@ class MyClass {
    int add_one() { return ++*ptr; }
 };

-void main() {
+void main()
+{
    boost::scoped_ptr&lt;Shoe&gt; x(new Shoe);
    MyClass my_instance;
-    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; std::endl;
-    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; std::endl;
+    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
+    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
 }</pre>
-<p>The example program produces the beginning of a child's nursery rhyme as
-output:</p>
+		</blockquote>
+		<p>The example program produces the beginning of a child's nursery rhyme:</p>
 		<blockquote>
 			<pre>1
 2
 Buckle my shoe</pre>
 		</blockquote>
 		<h2>Rationale</h2>
-<p>The primary reason to use <b> scoped_ptr</b> rather than <b> auto_ptr</b> is to let readers
-of your code know that you intend "resource acquisition is initialization" to be applied only for the current scope, and have no intent to transfer
-ownership.</p>
-<p>A secondary reason to use <b> scoped_ptr</b> is to prevent a later maintenance programmer from adding a function that actually transfers
-ownership by returning the <b> auto_ptr</b> (because the maintenance programmer saw
-<b>auto_ptr</b>, and assumed ownership could safely be transferred.)&nbsp;</p>
-<p>Think of <b>bool</b> vs <b>int</b>.  We all know that under the covers <b> bool</b> is usually
-just an <b>int</b>.  Indeed, some argued against including <b> bool</b> in the
-C++ standard because of that.  But by coding <b> bool</b> rather than <b> int</b>, you tell your readers
-what your intent is.  Same with <b> scoped_ptr</b> - you are signaling intent.</p>
-<p>It has been suggested that <b>boost::scoped_ptr&lt;T&gt;</b> is equivalent to
-<b>std::auto_ptr&lt;T> const</b>.&nbsp; Ed Brey pointed out, however, that
-reset() will not work on a <b>std::auto_ptr&lt;T> const.</b></p>
+		<p>The primary reason to use <b>scoped_ptr</b> rather than <b>auto_ptr</b> is to 
+			let readers of your code know that you intend "resource acquisition is 
+			initialization" to be applied only for the current scope, and have no intent to 
+			transfer ownership.</p>
+		<p>A secondary reason to use <b>scoped_ptr</b> is to prevent a later maintenance 
+			programmer from adding a function that transfers ownership by returning the <b>auto_ptr</b>, 
+			because the maintenance programmer saw <b>auto_ptr</b>, and assumed ownership 
+			could safely be transferred.</p>
+		<p>Think of <b>bool</b> vs <b>int</b>. We all know that under the covers <b>bool</b>
+			is usually just an <b>int</b>. Indeed, some argued against including <b>bool</b>
+			in the C++ standard because of that. But by coding <b>bool</b> rather than <b>int</b>, 
+			you tell your readers what your intent is. Same with <b>scoped_ptr</b>; by 
+			using it you are signaling intent.</p>
+		<p>It has been suggested that <b>scoped_ptr&lt;T&gt;</b> is equivalent to <b>std::auto_ptr&lt;T&gt; 
+				const</b>. Ed Brey pointed out, however, that <b>reset</b> will not work on 
+			a <b>std::auto_ptr&lt;T&gt; const.</b></p>
 		<h2><a name="Handle/Body">Handle/Body</a> Idiom</h2>
-<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
+		<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="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>, 
 			which uses a <b>scoped_ptr&lt;&gt;</b> to an incomplete type to hide the 
-implementation.&nbsp;&nbsp; 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>
-<h2>FAQ</h2>
+			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>
+		<h2>Frequently Asked Questions</h2>
 		<p><b>Q</b>. Why doesn't <b>scoped_ptr</b> have a release() member?<br>
-<b>A</b>. Because the whole point of <b>scoped_ptr</b> is to signal intent not
-to transfer ownership.&nbsp; Use <b>std::auto_ptr</b> if ownership transfer is
-required.</p>
+			<b>A</b>. When reading source code, it is valuable to be able to draw 
+			conclusions about program behavior based on the types being used. If <STRONG>scoped_ptr</STRONG>
+			had a release() member, it would become possible to transfer ownership of the 
+			held pointer, weakening its role as a way of limiting resource lifetime to a 
+			given context. Use <STRONG>std::auto_ptr</STRONG> where transfer of ownership 
+			is required. (supplied by Dave Abrahams)</p>
 		<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->24 May 2001<!--webbot bot="Timestamp" endspan i-checksum="15110" --></p>
-<p><EFBFBD> Copyright Greg Colvin and Beman Dawes 1999. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
-
+		<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->
+			17 September 2002<!--webbot bot="Timestamp" endspan i-checksum="15110" --></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>
 	</body>
-
 </html>
--- a/scoped_ptr_example.hpp
+++ b/scoped_ptr_example.hpp
@@ -1,6 +1,7 @@
 //  Boost scoped_ptr_example header file  ------------------------------------//

-#include <boost/smart_ptr.hpp>
+#include <boost/utility.hpp>
+#include <boost/scoped_ptr.hpp>

 //  The point of this example is to prove that even though
 //  example::implementation is an incomplete type in translation units using
@@ -8,7 +9,7 @@
 //  is complete where it counts - in the inplementation translation unit where
 //  destruction is actually instantiated.

-class example : boost::noncopyable
+class example : private boost::noncopyable
 {
 public:
  example();
--- a/shared_array.htm
+++ b/shared_array.htm
@@ -1,189 +1,179 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-
 	<head>
 		<title>shared_array</title>
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
+		<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="center" width="277" height="86">Class
-<a name="shared_array">shared_array</a></h1>
-<p>Class <strong>shared_array</strong> stores a pointer to a dynamically
-allocated array. (Dynamically allocated arrays are allocated with the C++ <tt>new[]</tt>
-expression.)&nbsp;&nbsp; The array pointed to is guaranteed to be deleted,
-either on destruction of the <strong>shared_array</strong>, on <strong>shared_array::operator=()</strong>,
-or via an explicit <strong>shared_array::reset()</strong>.&nbsp; See <a href="#shared_array_example">example</a>.</p>
-<p>Class<strong> shared_array</strong> meets the <strong>CopyConstuctible</strong>
-and <strong>Assignable</strong> requirements of the C++ Standard Library, and so
-can be used in C++ Standard Library containers.&nbsp; A specialization of std::
-less&lt; &gt; for&nbsp; boost::shared_ptr&lt;Y&gt; is supplied so that&nbsp;<strong>
-shared_array</strong> works by default for Standard Library's Associative
-Container Compare template parameter.&nbsp; For compilers not supporting partial
-specialization, the user must explicitly pass the less&lt;&gt; functor.</p>
-<p>Class<strong> shared_array</strong> cannot correctly hold a pointer to a
-single object.&nbsp; See <a href="shared_ptr.htm"><strong>shared_ptr</strong></a>
-for that usage.</p>
-<p>Class<strong> shared_array</strong> will not work correctly with cyclic data
-structures. For example, if main() holds a shared_array pointing to array A,
-which directly or indirectly holds a shared_array pointing back to array A, then
-array A's use_count() will be 2, and destruction of the main() shared_array will
-leave array A dangling with a use_count() of 1.</p>
-<p>A C++ Standard Library <strong>vector</strong> is <strong> </strong>a <strong>
-</strong>heavier duty alternative to a <strong>shared_array</strong>.</p>
-<p>The class is a template parameterized on <tt>T</tt>, the type of the object
-pointed to.&nbsp;&nbsp; <tt>T</tt> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">Common
-requirements</a>.</p>
-<h2>Class shared_array Synopsis</h2>
-<pre>#include &lt;<a href="../../boost/smart_ptr.hpp">boost/smart_ptr.hpp</a>&gt;
-namespace boost {
+	<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 
+			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>
+			expression.) The object pointed to is guaranteed to be deleted when the last <b>shared_array</b>
+			pointing to it is destroyed or reset.</p>
+		<p>Every <b>shared_array</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>shared_array</b>
+			works with the standard library's associative containers.</p>
+		<p>Normally, a <b>shared_array</b> cannot correctly hold a pointer to an object 
+			that has been allocated with the non-array form of <STRONG>new</STRONG>. See <a href="shared_ptr.htm">
+				<b>shared_ptr</b></a> for that usage.</p>
+		<p>Because the implementation uses reference counting, cycles of <b>shared_array</b>
+			instances will not be reclaimed. For example, if <b>main()</b> holds a <b>shared_array</b>
+			to <b>A</b>, which directly or indirectly holds a <b>shared_array</b> back to <b>A</b>,
+			<b>A</b>'s use count will be 2. Destruction of the original <b>shared_array</b> 
+			will leave <b>A</b> dangling with a use count of 1.</p>
+		<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">
+				common requirements</a>.</p>
+		<h2>Synopsis</h2>
+		<pre>namespace boost {

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

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

-   explicit <a href="#shared_array_ctor">shared_array</a>( T* p=0 );
-   <a href="#shared_array_ctor">shared_array</a>( const shared_array&amp; );  // never throws   
-  <strong> </strong><a href="#shared_array_~shared_array">~shared_array</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);
+      <a href="#destructor">~shared_array</a>(); // never throws

-   shared_array&amp; <a href="#shared_array_operator=">operator=</a>( const shared_array&amp; );  // never throws  
+      <a href="#constructors">shared_array</a>(shared_array const &amp; r); // never throws

-   void <a href="#shared_array_reset">reset</a>( T* p=0 );
+      shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws

-   T&amp; <a href="#shared_array_operator[]">operator[]</a>(std::size_t i) const;  // never throws
-   T* <a href="#shared_array_get">get</a>() const;  // 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);

-   long <a href="#shared_array_use_count">use_count</a>() const;  // never throws
-   bool <a href="#shared_array_unique">unique</a>() const;  // never throws
+      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const() const; // never throws
+      T * <a href="#get">get</a>() const; // never throws

-   void <a href="#shared_array_swap">swap</a>( shared_array&lt;T&gt;&amp; other ) throw()
+      bool <a href="#unique">unique</a>() const; // never throws
+      long <a href="#use_count">use_count</a>() const; // never throws
+
+      void <a href="#swap">swap</a>(shared_array&lt;T&gt; &amp; b); // never throws
  };

  template&lt;typename T&gt;
-  inline bool operator==(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b)
-    { return a.get() == b.get(); }
-
+    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;
-  inline bool operator!=(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b)
-    { return a.get() != b.get(); }
+    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;
+    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
+
 }</pre>
-<pre>namespace std {
-
-template&lt;typename T&gt;
-  inline void swap(boost::shared_array&lt;T&gt;&amp; a, boost::shared_array&lt;T&gt;&amp; b)
-    { a.swap(b); }
-
-template&lt;typename T&gt;
-  struct less&lt; boost::shared_array&lt;T&gt; &gt;
-    : binary_function&lt;boost::shared_array&lt;T&gt;, boost::shared_array&lt;T&gt;, bool&gt;
-  {
-    bool operator()(const boost::shared_array&lt;T&gt;&amp; a,
-        const boost::shared_array&lt;T&gt;&amp; b) const
-      { return less&lt;T*&gt;()(a.get(),b.get()); }
-  };
-
-} // namespace std </pre>
-<p>Specialization of std::swap uses the fast, non-throwing swap that's provided
-as a member function instead of using the default algorithm which creates a
-temporary and uses assignment.<br>
-<br>
-Specialization of std::less allows use of shared arrays as keys in&nbsp;C++
-Standard Library associative collections.<br>
-<br>
-The std::less specializations use std::less&lt;T*&gt; to perform the
-comparison.&nbsp; This insures that pointers are handled correctly, since the
-standard mandates that relational operations on pointers are unspecified (5.9 [expr.rel]
-paragraph 2) but std::less&lt;&gt; on pointers is well-defined (20.3.3 [lib.comparisons]
-paragraph 8).<br>
-<br>
-It's still a controversial question whether supplying only std::less is better
-than supplying a full range of comparison operators (&lt;, &gt;, &lt;=, &gt;=).</p>
-<p>The current implementation does not supply the specializations if the macro
-name BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined.</p>
-<h2>Class shared_array Members</h2>
-<h3>shared_array <a name="shared_array_element_type">element_type</a></h3>
+		<h2>Members</h2>
+		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
 		<p>Provides the type of the stored pointer.</p>
-<h3><a name="shared_array_ctor">shared_array constructors</a></h3>
+		<h3><a name="constructors">constructors</a></h3>
 		<pre>explicit shared_array(T * p = 0);</pre>
-<p>Constructs a <strong>shared_array</strong>, storing a copy of <tt>p</tt>,
-which must have been allocated via a C++ <tt>new</tt>[] expression or be 0.
-Afterwards, use_count() is 1 (even if p==0; see <a href="#shared_array_~shared_array">~shared_array</a>).</p>
-<p>The only exception which may be thrown is <tt>std::bad_alloc</tt>.&nbsp; If
-an exception is thrown,&nbsp; <tt>delete[] p</tt> is called.</p>
-<pre>shared_array( const shared_array&amp; r);  // never throws</pre>
-<p>Constructs a <strong>shared_array</strong>, as if by storing a copy of the
-pointer stored in <strong>r</strong>. Afterwards, <strong>use_count()</strong>
-for all copies is 1 more than the initial <strong>r.use_count()</strong>.</p>
-<h3><a name="shared_array_~shared_array">shared_array destructor</a></h3>
-<pre>~shared_array();</pre>
-<p>If <strong>use_count()</strong> == 1, deletes the array pointed to by the
-stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any remaining
-copies is decremented by 1. Note that in C++ <tt>delete</tt>[] on a pointer with
-a value of 0 is harmless.</p>
-<p>Does not throw exceptions.</p>
-<h3>shared_array <a name="shared_array_operator=">operator=</a></h3>
-<pre>shared_array&amp; operator=( const shared_array&amp; r);  // never throws</pre>
-<p>First, if <strong>use_count()</strong> == 1, deletes the array pointed to by
-the stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any
-remaining copies is decremented by 1. Note that in C++ <tt>delete</tt>[] on a
-pointer with a value of 0 is harmless.</p>
-<p>Then replaces the contents of <strong>this</strong>, as if by storing a copy
-of the pointer stored in <strong>r</strong>. Afterwards, <strong>use_count()</strong>
-for all copies is 1 more than the initial <strong>r.use_count()</strong>.&nbsp;</p>
-<h3>shared_array <a name="shared_array_reset">reset</a></h3>
+		<p>Constructs a <b>shared_array</b>, storing a copy of <b>p</b>, which must be a 
+			pointer to an array that was allocated via a C++ <b>new[]</b> expression or be 
+			0. Afterwards, the <a href="#use_count">use count</a> is 1 (even if p == 0; see <a href="#destructor">
+				~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>
+		<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 
+			the array pointed to by <b>p</b>, the object <b>d</b> is used in the statement <b>d(p)</b>. 
+			Invoking the object <b>d</b> with parameter <b>p</b> in this way must not 
+			throw. The only exception which may be thrown by this constructor is <b>std::bad_alloc</b>. 
+			If an exception is thrown, <b>d(p)</b> is called.</p>
+		<pre>shared_array(shared_array const &amp; r); // never throws</pre>
+		<p>Constructs a <b>shared_array</b>, as if by storing a copy of the pointer stored 
+			in <b>r</b>. Afterwards, the <a href="#use_count">use count</a> for all copies 
+			is 1 more than the initial use count.</p>
+		<h3><a name="destructor">destructor</a></h3>
+		<pre>~shared_array(); // never throws</pre>
+		<p>Decrements the <a href="#use_count">use count</a>. Then, if the use count is 0, 
+			deletes the array pointed to by the stored pointer. Note that <b>delete[]</b> on 
+			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>
+		<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>
+		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(T * p = 0);</pre>
-<p>First, if <strong>use_count()</strong> == 1, deletes the array pointed to by
-the stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any
-remaining copies is decremented by 1. Note that in C++&nbsp; <tt>delete</tt>[]
-on a pointer with a value of 0 is harmless.</p>
-<p>Then replaces the contents of <strong>this</strong>, as if by storing a copy
-of <strong>p</strong>, which must have been allocated via a C++ <tt>new</tt>[]
-expression or be 0. Afterwards, <strong>use_count()</strong> is 1 (even if p==0;
-see <a href="#shared_array_~shared_array">~shared_array</a>).</p>
-<p>The only exception which may be thrown is <tt>std::bad_alloc</tt>.&nbsp; If
-an exception is thrown,&nbsp; <tt>delete[] p</tt> is called.</p>
-<h3>shared_array <a name="shared_array_operator[]">operator[]</a></h3>
-<p><tt>T&amp; operator[](std::size_t i) const; // never throws</tt></p>
-<p>Returns a reference to element <tt>i</tt> of the array pointed to by the
-stored pointer.</p>
-<p>Behavior is undefined (and almost certainly undesirable) if <tt>get()==0</tt>,
-or if <tt>i</tt> is less than 0 or is greater or equal to the number of elements
-in the array.</p>
-<h3>shared_array <a name="shared_array_get">get</a></h3>
+		<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. 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>
+		<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>
+		<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 
+			pointer is 0, or if <b>i</b> is less than 0 or is greater than or equal to the 
+			number of elements in the array.</p>
+		<h3><a name="get">get</a></h3>
 		<pre>T * get() const; // never throws</pre>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns the stored pointer.</p>
-<h3>shared_array<a name="shared_array_use_count"> use_count</a></h3>
-<p><tt>long use_count() const; // never throws</tt></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns the number of <strong>shared_arrays</strong> sharing ownership of the
-stored pointer.</p>
-<h3>shared_array <a name="shared_array_unique">unique</a></h3>
-<p><tt>bool unique() const; // never throws</tt></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns <strong>use_count()</strong> == 1.</p>
-<h3><a name="shared_array_swap">shared_array swap</a></h3>
-<p><code>void swap( shared_array&lt;T&gt;&amp; other ) throw()</code></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Swaps the two smart pointers, as if by std::swap.</p>
-<h2>Class <a name="shared_array_example">shared_array example</a></h2>
-<p>[To be supplied. In the meantime, see <a href="smart_ptr_test.cpp">smart_ptr_test.cpp</a>.]</p>
+		<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>
+		<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>
+		<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">
+				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 
+			count, it might be removed from some future version. Thus it should be used for 
+			debugging purposes only, and not production code.</p>
+		<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 
+				requirements</a>.</p>
+		<h2><a name="functions">Free Functions</a></h2>
+		<h3><a name="comparison">comparison</a></h3>
+		<pre>template&lt;typename 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;
+  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;
+  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 
+				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 
+			implementation uses <b>std::less&lt;T *&gt;</b> to perform the comparison. This 
+			ensures that the comparison is handled correctly, since the standard mandates 
+			that relational operations on pointers are unspecified (5.9 [expr.rel] 
+			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;
+  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 -->24 May, 2001<!--webbot bot="Timestamp" endspan i-checksum="13964" -->
-</p>
-<p><EFBFBD> Copyright Greg Colvin and Beman Dawes 1999. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
-
+		<p>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>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>
--- a/shared_ptr.htm
+++ b/shared_ptr.htm
@@ -1,243 +1,678 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-
 	<head>
 		<title>shared_ptr</title>
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
+		<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 
+			class template</h1>
+		<p><A href="#Introduction">Introduction</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="#FAQ">Frequently Asked Questions</A><br>
+			<A href="smarttests.htm">Smart Pointer Timings</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 
+			guaranteed to be deleted when the last <b>shared_ptr</b> pointing to it is 
+			destroyed or reset. See the <A href="#example">example</A>.</p>
+		<p>Every <b>shared_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>shared_ptr</b> 
+			works with the standard library's associative containers.</p>
+		<p>Normally, a <b>shared_ptr</b> cannot correctly hold a pointer to a dynamically 
+			allocated array. See <A href="shared_array.htm"><b>shared_array</b></A> for 
+			that usage.</p>
+		<p>Because the implementation uses reference counting, cycles of <b>shared_ptr</b> instances 
+			will not be reclaimed. For example, if <b>main()</b> holds a <b>shared_ptr</b> to
+			<b>A</b>, which directly or indirectly holds a <b>shared_ptr</b> back to <b>A</b>,
+			<b>A</b>'s use count will be 2. Destruction of the original <b>shared_ptr</b> will 
+			leave <b>A</b> dangling with a use count of 1. Use <A href="weak_ptr.htm">weak_ptr</A>
+			to "break cycles."</p>
+		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
+			to. <STRONG>shared_ptr</STRONG> and most of its member functions place no 
+			requirements on <STRONG>T</STRONG>; it is allowed to be an incomplete type, or <STRONG>
+				void</STRONG>. Member functions that do place additional requirements (<A href="#constructors">constructors</A>,
+			<A href="#reset">reset</A>) are explicitly documented below.</p>
+		<P><STRONG>shared_ptr&lt;T&gt;</STRONG> can be implicitly converted to <STRONG>shared_ptr&lt;U&gt;</STRONG>
+			whenever <STRONG>T*</STRONG> can be implicitly converted to <STRONG>U*</STRONG>. 
+			In particular, <STRONG>shared_ptr&lt;T&gt;</STRONG> is implicitly convertible 
+			to <STRONG>shared_ptr&lt;T const&gt;</STRONG>, to <STRONG>shared_ptr&lt;U&gt;</STRONG>
+			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 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 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);
+int g();

-<body bgcolor="#FFFFFF" text="#000000">
+void ok()
+{
+    shared_ptr&lt;int&gt; p(new int(2));
+    f(p, g());
+}

-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Class
-<a name="shared_ptr">shared_ptr</a></h1>
-<p>Class <strong>shared_ptr</strong> stores a pointer to a dynamically allocated
-object. (Dynamically allocated objects are allocated with the C++ <tt>new</tt>
-expression.)&nbsp;&nbsp; The object pointed to is guaranteed to be deleted when
-the last <strong>shared_ptr</strong> pointing to it is deleted or reset.&nbsp;
-See <a href="#shared_ptr_example">example</a>.</p>
-<p>Class<strong> shared_ptr</strong> meets the <strong>CopyConstuctible</strong>
-and <strong>Assignable</strong> requirements of the C++ Standard Library, and so
-can be used in C++ Standard Library containers.&nbsp; A specialization of std::
-less&lt; &gt; for&nbsp; boost::shared_ptr&lt;Y&gt; is supplied so that&nbsp;<strong>
-shared_ptr</strong> works by default for Standard Library's Associative
-Container Compare template parameter.&nbsp; For compilers not supporting partial
-specialization, the user must explicitly pass the less&lt;&gt; functor.</p>
-<p>Class<strong> shared_ptr</strong> cannot correctly hold a pointer to a
-dynamically allocated array.&nbsp; See <a href="shared_array.htm"><strong>shared_array</strong></a>
-for that usage.</p>
-<p>Class<strong> shared_ptr</strong> will not work correctly with cyclic data
-structures. For example, if main() holds a shared_ptr to object A, which
-directly or indirectly holds a shared_ptr back to object A, then object A's
-use_count() will be 2, and destruction of the main() shared_ptr will leave
-object A dangling with a use_count() of 1.</p>
-<p>The class is a template parameterized on <tt>T</tt>, the type of the object
-pointed to.&nbsp;&nbsp; <tt>T</tt> must meet the smart pointer <a href="smart_ptr.htm#Common requirements">Common
-requirements</a>.</p>
-<h2>Class shared_ptr Synopsis</h2>
-<pre>#include &lt;<a href="../../boost/smart_ptr.hpp">boost/smart_ptr.hpp</a>&gt;
-namespace boost {
+void bad()
+{
+    f(shared_ptr&lt;int&gt;(new int(2)), g());
+}
+</PRE>
+		<P>The function <STRONG>ok</STRONG> follows the guideline to the letter, whereas <STRONG>
+				bad</STRONG> constructs the temporary <STRONG>shared_ptr</STRONG> in place, 
+			admitting the possibility of a memory leak. Since function arguments are 
+			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>
+		<h2><a name="Synopsis">Synopsis</a></h2>
+		<pre>namespace boost {
+
+  class use_count_is_zero: public std::exception;
+
+  template&lt;typename T&gt; class <A href="weak_ptr.htm" >weak_ptr</A>;

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

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

-   explicit <a href="#shared_ptr_ctor">shared_ptr</a>( T* p=0 );
-  <strong> </strong><a href="#shared_ptr_~shared_ptr">~shared_ptr</a>();
+      typedef T <A href="#element_type" >element_type</A>;

-   <a href="#shared_ptr_ctor">shared_ptr</a>( const shared_ptr&amp; );   
-   template&lt;typename Y&gt;
-      <a href="#shared_ptr_ctor">shared_ptr</a>(const shared_ptr&lt;Y&gt;&amp; r);  // never throws
-   template&lt;typename Y&gt;
-      <a href="#shared_ptr_ctor">shared_ptr</a>(std::auto_ptr&lt;Y&gt;&amp; r);
+      <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="#destructor">~shared_ptr</A>(); // never throws

-   shared_ptr&amp; <a href="#shared_ptr_operator=">operator=</a>( const shared_ptr&amp; );  // never throws  
-   template&lt;typename Y&gt;
-      shared_ptr&amp; <a href="#shared_ptr_operator=">operator=</a>(const shared_ptr&lt;Y&gt;&amp; r);  // never throws
-   template&lt;typename Y&gt;
-      shared_ptr&amp; <a href="#shared_ptr_operator=">operator=</a>(std::auto_ptr&lt;Y&gt;&amp; r);
+      <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
+      template&lt;typename 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;typename Y&gt; explicit <A href="#constructors" >shared_ptr</A>(std::auto_ptr&lt;Y&gt; &amp; r);

-   void <a href="#shared_ptr_reset">reset</a>( T* p=0 );
+      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);

-   T&amp; <a href="#shared_ptr_operator*">operator*</a>() const;  // never throws
-   T* <a href="#shared_ptr_operator-&gt;">operator-&gt;</a>() const;  // never throws
-   T* <a href="#shared_ptr_get">get</a>() const;  // never throws
+      void <A href="#reset" >reset</A>();
+      template&lt;typename Y&gt; void <A href="#reset" >reset</A>(Y * p);
+      template&lt;typename Y, typename D&gt; void <A href="#reset" >reset</A>(Y * p, D d);

-   long <a href="#shared_ptr_use_count">use_count</a>() const;  // never throws
-   bool <a href="#shared_ptr_unique">unique</a>() const;  // never throws
+      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

-   void <a href="#shared_ptr_swap">swap</a>( shared_ptr&lt;T&gt;&amp; other ) throw()
+      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
+
+      void <A href="#swap" >swap</A>(shared_ptr &amp; b); // never throws
  };

  template&lt;typename T, typename U&gt;
-  inline bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b)
-    { return a.get() == b.get(); }
+    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;
+    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;typename T&gt; T * <A href="#get_pointer" >get_pointer</A>(shared_ptr&lt;T&gt; const &amp; p); // never throws

  template&lt;typename T, typename U&gt;
-  inline bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b)
-    { return a.get() != b.get(); }
+    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
+
 }</pre>
-<pre>namespace std {
-
-template&lt;typename T&gt;
-  inline void swap(boost::shared_ptr&lt;T&gt;&amp; a, boost::shared_ptr&lt;T&gt;&amp; b)
-    { a.swap(b); }
-
-template&lt;typename T&gt;
-  struct less&lt; boost::shared_ptr&lt;T&gt; &gt;
-    : binary_function&lt;boost::shared_ptr&lt;T&gt;, boost::shared_ptr&lt;T&gt;, bool&gt;
-  {
-    bool operator()(const boost::shared_ptr&lt;T&gt;&amp; a,
-        const boost::shared_ptr&lt;T&gt;&amp; b) const
-      { return less&lt;T*&gt;()(a.get(),b.get()); }
-  };
-
-} // namespace std </pre>
-<p>Specialization of std::swap uses the fast, non-throwing swap that's provided
-as a member function instead of using the default algorithm which creates a
-temporary and uses assignment.<br>
-<br>
-Specialization of std::less allows use of shared pointers as keys in&nbsp;C++
-Standard Library associative collections.<br>
-<br>
-The std::less specializations use std::less&lt;T*&gt; to perform the
-comparison.&nbsp; This insures that pointers are handled correctly, since the
-standard mandates that relational operations on pointers are unspecified (5.9 [expr.rel]
-paragraph 2) but std::less&lt;&gt; on pointers is well-defined (20.3.3 [lib.comparisons]
-paragraph 8).<br>
-<br>
-It's still a controversial question whether supplying only std::less is better
-than supplying a full range of comparison operators (&lt;, &gt;, &lt;=, &gt;=).</p>
-<p>The current implementation does not supply the specializations if the macro
-name BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined.</p>
-<p>The current implementation does not supply the member template functions if
-the macro name BOOST_NO_MEMBER_TEMPLATES is defined.</p>
-<h2>Class shared_ptr Members</h2>
-<h3>shared_ptr <a name="shared_ptr_element_type">element_type</a></h3>
+		<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 
+				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>
+		<h2><a name="Members">Members</a></h2>
+		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
-<p>Provides the type of the stored pointer.</p>
-<h3><a name="shared_ptr_ctor">shared_ptr constructors</a></h3>
-<pre>explicit shared_ptr( T* p=0 );</pre>
-<p>Constructs a <strong>shared_ptr</strong>, storing a copy of <tt>p</tt>, which
-must have been allocated via a C++ <tt>new</tt> expression or be 0. Afterwards, <strong>use_count()</strong>
-is 1 (even if p==0; see <a href="#shared_ptr_~shared_ptr">~shared_ptr</a>).</p>
-<p>The only exception which may be thrown by this constructor is <tt>std::bad_alloc</tt>.&nbsp;&nbsp;
-If an exception is thrown,&nbsp; <tt>delete p</tt> is called.</p>
-<pre>shared_ptr( const shared_ptr&amp; r);  // never throws   
-template&lt;typename Y&gt;
-   shared_ptr(const shared_ptr&lt;Y&gt;&amp; r);  // never throws
-template&lt;typename Y&gt;
-   shared_ptr(std::auto_ptr&lt;Y&gt;&amp; r);</pre>
-<p>Constructs a <strong>shared_ptr</strong>, as if by storing a copy of the
-pointer stored in <strong>r</strong>. Afterwards, <strong>use_count()</strong>
-for all copies is 1 more than the initial <strong>r.use_count()</strong>, or 1
-in the <strong>auto_ptr</strong> case. In the <strong>auto_ptr</strong> case, <strong>r.release()</strong>
-is called.</p>
-<p>The only exception which may be thrown by the constructor from <strong>auto_ptr</strong>
-is <tt>std::bad_alloc</tt>.&nbsp;&nbsp; If an exception is thrown, that
-constructor has no effect.</p>
-<h3><a name="shared_ptr_~shared_ptr">shared_ptr destructor</a></h3>
-<pre>~shared_ptr();</pre>
-<p>If <strong>use_count()</strong> == 1, deletes the object pointed to by the
-stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any remaining
-copies is decremented by 1. Note that in C++&nbsp; <tt>delete</tt> on a pointer
-with a value of 0 is harmless.</p>
-<p>Does not throw exceptions.</p>
-<h3>shared_ptr <a name="shared_ptr_operator=">operator=</a></h3>
-<pre>shared_ptr&amp; operator=( const shared_ptr&amp; r);  
-template&lt;typename Y&gt;
-   shared_ptr&amp; operator=(const shared_ptr&lt;Y&gt;&amp; r);
-template&lt;typename Y&gt;
-   shared_ptr&amp; operator=(std::auto_ptr&lt;Y&gt;&amp; r);</pre>
-<p>First, if <strong>use_count()</strong> == 1, deletes the object pointed to by
-the stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any
-remaining copies is decremented by 1. Note that in C++&nbsp; <tt>delete</tt> on
-a pointer with a value of 0 is harmless.</p>
-<p>Then replaces the contents of <strong>this</strong>, as if by storing a copy
-of the pointer stored in <strong>r</strong>. Afterwards, <strong>use_count()</strong>
-for all copies is 1 more than the initial <strong>r.use_count()</strong>, or 1
-in the <strong>auto_ptr</strong> case. In the <strong>auto_ptr</strong> case, <strong>r.release()</strong>
-is called.</p>
-<p>The first two forms of <tt>operator=</tt> above do not throw exceptions.</p>
-<p>The only exception which may be thrown by the <strong>auto_ptr</strong> form
-is <tt>std::bad_alloc</tt>.&nbsp;&nbsp; If an exception is thrown, the function
-has no effect.</p>
-<h3>shared_ptr <a name="shared_ptr_reset">reset</a></h3>
-<pre>void reset( T* p=0 );</pre>
-<p>First, if <strong>use_count()</strong> == 1, deletes the object pointed to by
-the stored pointer.&nbsp;Otherwise, <strong>use_count()</strong> for any
-remaining copies is decremented by 1.&nbsp;</p>
-<p>Then replaces the contents of <strong>this</strong>, as if by storing a copy
-of <strong>p</strong>, which must have been allocated via a C++ <tt>new</tt>
-expression or be 0. Afterwards, <strong>use_count()</strong> is 1 (even if p==0;
-see <a href="#shared_ptr_~shared_ptr">~shared_ptr</a>). Note that in C++&nbsp; <tt>delete</tt>
-on a pointer with a value of 0 is harmless.</p>
-<p>The only exception which may be thrown is <tt>std::bad_alloc</tt>.&nbsp; If
-an exception is thrown,&nbsp; <tt>delete p</tt> is called.</p>
-<h3>shared_ptr <a name="shared_ptr_operator*">operator*</a></h3>
-<pre>T&amp; operator*() const;  // never throws</pre>
-<p>Returns a reference to the object pointed to by the stored pointer.</p>
-<h3>shared_ptr <a name="shared_ptr_operator-&gt;">operator-&gt;</a> and <a name="shared_ptr_get">get</a></h3>
-<pre>T* operator-&gt;() const;  // never throws
-T* get() const;  // never throws</pre>
-<p><b>T</b> is not required by get() to be a complete type .&nbsp; See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Both return the stored pointer.</p>
-<h3>shared_ptr<a name="shared_ptr_use_count"> use_count</a></h3>
-<p><tt>long use_count() const; // never throws</tt></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns the number of <strong>shared_ptrs</strong> sharing ownership of the
-stored pointer.</p>
-<h3>shared_ptr <a name="shared_ptr_unique">unique</a></h3>
-<p><tt>bool unique() const; // never throws</tt></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Returns <strong>use_count()</strong> == 1.</p>
-<h3><a name="shared_ptr_swap">shared_ptr swap</a></h3>
-<p><code>void swap( shared_ptr&lt;T&gt;&amp; other ) throw()</code></p>
-<p><b>T</b> is not required be a complete type.&nbsp;
-See <a href="smart_ptr.htm#Common requirements">Common Requirements</a>.</p>
-<p>Swaps the two smart pointers, as if by std::swap.</p>
-<h2>Class <a name="shared_ptr_example">shared_ptr example</a></h2>
-<p>See <a href="shared_ptr_example.cpp"> shared_ptr_example.cpp</a> for a complete example program.</p>
-<p>This program builds a std::vector and std::set of FooPtr's.</p>
-<p>Note that after the two containers have been populated, some of the FooPtr objects
-will have use_count()==1 rather than use_count()==2, since foo_set is a std::set
-rather than a std::multiset, and thus does not contain duplicate entries.&nbsp; Furthermore, use_count() may be even higher
-at various times while push_back() and insert() container operations are performed.&nbsp;
-More complicated yet, the container operations may throw exceptions under a
-variety of circumstances.&nbsp; Without using a smart pointer, memory and
-exception management would be a nightmare.</p>
-<h2><a name="Handle/Body">Handle/Body</a> Idiom</h2>
-<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>,
-which uses a <b>shared_ptr&lt;&gt;</b> to an incomplete type to hide the
-implementation.&nbsp;&nbsp; The
-instantiation of member functions which require a complete type occurs in the <a href="shared_ptr_example2.cpp">shared_ptr_example2.cpp</a>
-implementation file.</p>
-<h2>FAQ</h2>
-<p><b>Q</b>. Why doesn't <b>shared_ptr</b> have template parameters supplying
-traits or policies to allow extensive user customization?<br>
-<b>A</b>. Parameterization discourages users.&nbsp; <b>Shared_ptr</b> is
-carefully crafted to meet common needs without extensive parameterization.
-Someday a highly configurable smart pointer may be invented that is also very
-easy to use and very hard to misuse.&nbsp; Until then, <b>shared_ptr</b> is the
-smart pointer of choice for a wide range of applications.</p>
-<p><b>Q</b>. Why don't <b>shared_ptr</b> (and 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>
-<hr>
-<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->24 May, 2001<!--webbot bot="Timestamp" endspan i-checksum="13964" -->
+		<blockquote>
+			<p>Provides the type of the template parameter T.</p>
+		</blockquote>
+		<h3><a name="constructors">constructors</a></h3>
+		<pre>shared_ptr();</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>
+		</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 
+				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>
+		<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>
+		<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><EFBFBD> Copyright Greg Colvin and Beman Dawes 1999. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
+			<p><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>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 
+				allocated via a C++ <B>new</B> expression or be 0. The postcondition that <A href="#use_count">
+					use count</A> is 1 holds even if <b>p</b> is 0; invoking <STRONG>delete</STRONG>
+				on a pointer that has a value of 0 is harmless.</P>
+		</blockquote>
+		<P><EM>[This constructor has been changed to a template in order to remember the actual 
+				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 is difficult; it needs to be initialized before any <STRONG>shared_ptr</STRONG>
+				instances are constructed, and the initialization needs to be 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, the ability to make a <STRONG>shared_ptr</STRONG>
+				from <STRONG>this</STRONG> is considered essential by experienced smart 
+				pointer users.</EM><EM>]</EM></P>
+		<pre>template&lt;typename Y, typename 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>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>
+				as an argument.</p>
+		</blockquote>
+		<P><EM>[Custom deallocators allow a factory function returning a <STRONG>shared_ptr</STRONG>
+				to insulate the user from its memory allocation strategy. Since the deallocator 
+				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>
+		<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 comes from 
+				the pass by value. If the copy constructor throws, the pointer is leaked. 
+				Removing the requirement requires a pass by (const) reference. The problems are 
+				that (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 requrement will be removed when the aforementioned issues are 
+				resolved.]</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>
+		<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> nothing.</p>
+		</blockquote>
+		<P><EM>[The postcondition will be relaxed when a default-constructed <STRONG>shared_ptr</STRONG>
+				is being copied.]</EM></P>
+		<pre>template&lt;typename 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>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>
+		<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>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>
+		<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>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>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>shared_ptr(r).swap(*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);
+shared_ptr&lt;void&gt; q(p);
+p = p;
+q = p;
+</pre>
+			<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 
+				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>
+		<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>
+		<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>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>shared_ptr(p, d).swap(*this)</code>.</P>
+		</BLOCKQUOTE>
+		<h3><a name="indirection">indirection</a></h3>
+		<pre>T &amp; operator*() const; // never throws</pre>
+		<blockquote>
+			<p><b>Requirements:</b> The stored pointer must not be 0.</p>
+			<p><b>Returns:</b> a reference to the object pointed to by the stored pointer.</p>
+			<p><b>Throws:</b> nothing.</p>
+		</blockquote>
+		<pre>T * operator-&gt;() const; // never throws</pre>
+		<blockquote>
+			<p><b>Requirements:</b> The stored pointer must not be 0.</p>
+			<p><b>Returns:</b> the stored pointer.</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="unique">unique</a></h3>
+		<pre>bool unique() const; // never throws</pre>
+		<blockquote>
+			<p><b>Returns:</b> <code>use_count() == 1</code>.</p>
+			<p><b>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> <code>unique()</code> may be faster than <code>use_count()</code>. 
+				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>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="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>shared_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>
+		<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>
+		<h3><a name="swap">swap</a></h3>
+		<pre>void swap(shared_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;typename T, typename 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;
+  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>
+		<blockquote>
+			<p><b>Returns:</b> an 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>Throws:</b> nothing.</p>
+			<P><B>Notes:</B> Allows <STRONG>shared_ptr</STRONG> objects to be used as keys in 
+				associative containers.</P>
+		</blockquote>
+		<P><EM>[<STRONG>Operator&lt;</STRONG> has been preferred over a <STRONG>std::less </STRONG>
+				specialization for consistency and legality reasons, as <STRONG>std::less</STRONG>
+				is required to return the results of <STRONG>operator&lt;</STRONG>, and many 
+				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' <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;
+  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>
+			<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>
+		<P><EM>[<STRONG>swap</STRONG> is defined in the same namespace as <STRONG>shared_ptr</STRONG>
+				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;
+  T * get_pointer(shared_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="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>
+		<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>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>
+		<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>
+			<P><B>Returns:</B></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>;
+				<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>
+			<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>
+		<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>
+		</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>
+		<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>
+		</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>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 
+			contain duplicate entries. Furthermore, the use count may be even higher at 
+			various times while <b>push_back</b> and <b>insert</b> container operations are 
+			performed. More complicated yet, the container operations may throw exceptions 
+			under a variety of circumstances. Getting the memory management and exception 
+			handling in this example right without a smart pointer would be a nightmare.</p>
+		<h2><a name="Handle/Body">Handle/Body</a> Idiom</h2>
+		<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>, 
+			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>
+			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. 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));

+//--- Example 1 ---
+
+// thread A
+shared_ptr&lt;int&gt; p2(p); // reads p
+
+// thread B
+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
+p2.reset(); // OK, writes p2
+
+//--- Example 3 ---
+
+// thread A
+p = p3; // reads p3, writes p
+
+// thread B
+p3.reset(); // writes p3; undefined, simultaneous read/write
+
+//--- Example 4 ---
+
+// thread A
+p3 = p2; // reads p2, writes p3
+
+// thread B
+// p2 goes out of scope: undefined, the destructor is considered a "write access"
+
+//--- Example 5 ---
+
+// thread A
+p3.reset(new int(1));
+
+// thread B
+p3.reset(new int(2)); // undefined, multiple writes
+</pre>
+		<p><STRONG>shared_ptr</STRONG> uses <A href="../config/config.htm">Boost.Config</A> 
+			to detect whether the implementation supports threads. If your program is 
+			single-threaded, but your platform is autodetected by <STRONG>Boost.Config</STRONG>
+			as supporting multiple threads, <STRONG>#define BOOST_DISABLE_THREADS</STRONG> to 
+			eliminate the thread safety overhead.</p>
+		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
+		<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>
+			<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>
+		<P><B>Q.</B> Why doesn't <B>shared_ptr</B> have template parameters supplying 
+			traits or policies to allow extensive user customization?<BR>
+			<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>
+		<P><B>Q.</B> I am not convinced. Default parameters can be used where appropriate 
+			to hide the complexity. Again, why not policies?<BR>
+			<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>
+			<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>
+			<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>
+			<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>
+			<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>
+		<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
+
+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>
+		<hr>
+		<p>Revised $Date$</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>
 	</body>
-
 </html>
--- a/shared_ptr_assign_fail.cpp
+++ b/shared_ptr_assign_fail.cpp
@@ -0,0 +1,31 @@
+#if defined(_MSC_VER) && !defined(__ICL)
+#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_ptr_assign_fail.cpp - a negative test for shared_ptr assignment
+//
+//  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.
+//
+
+#include <boost/shared_ptr.hpp>
+
+bool boost_error(char const *, char const *, char const *, long)
+{
+    return true;
+}
+
+int main()
+{
+    boost::shared_ptr<int> p;
+    p = new int(42); // assignment must fail
+    return 0;
+}
--- a/shared_ptr_example.cpp
+++ b/shared_ptr_example.cpp
@@ -20,7 +20,7 @@
 #include <set>
 #include <iostream>
 #include <algorithm>
-#include <boost/smart_ptr.hpp>
+#include <boost/shared_ptr.hpp>

 //  The application will produce a series of
 //  objects of type Foo which later must be
--- a/shared_ptr_example2.cpp
+++ b/shared_ptr_example2.cpp
@@ -17,5 +17,3 @@ example & example::operator=( const example & s )

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

-#include <boost/smart_ptr.hpp>
+#include <boost/shared_ptr.hpp>

 //  This example demonstrates the handle/body idiom (also called pimpl and
 //  several other names).  It separates the interface (in this header file)
@@ -16,7 +16,6 @@ class example
 {
 public:
  example();
-  ~example();
  example( const example & );
  example & operator=( const example & );
  void do_something();
--- a/shared_ptr_mt_test.cpp
+++ b/shared_ptr_mt_test.cpp
@@ -0,0 +1,178 @@
+#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#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_ptr_mt_test.cpp - tests shared_ptr with multiple threads
+//
+//  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.
+//
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+
+#include <vector>
+#include <memory>
+#include <stdexcept>
+
+#include <cstdio>
+#include <ctime>
+
+// 'portable' thread framework
+
+class abstract_thread
+{
+public:
+
+    virtual ~abstract_thread() {}
+    virtual void run() = 0;
+};
+
+#if !defined(BOOST_HAS_PTHREADS) && defined(BOOST_HAS_WINTHREADS)
+
+char const * title = "Using Windows threads";
+
+#include <windows.h>
+#include <process.h>
+
+typedef HANDLE pthread_t;
+
+unsigned __stdcall common_thread_routine(void * pv)
+{
+    abstract_thread * pt = static_cast<abstract_thread *>(pv);
+    pt->run();
+    delete pt;
+    return 0;
+}
+
+int pthread_create(pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg)
+{
+    HANDLE h = (HANDLE)_beginthreadex(0, 0, start_routine, arg, 0, 0);
+
+    if(h != 0)
+    {
+        *thread = h;
+        return 0;
+    }
+    else
+    {
+        return 1; // return errno;
+    }
+}
+
+int pthread_join(pthread_t thread, void ** /*value_ptr*/)
+{
+    ::WaitForSingleObject(thread, INFINITE);
+    ::CloseHandle(thread);
+    return 0;
+}
+
+#else
+
+char const * title = "Using POSIX threads";
+
+#include <pthread.h>
+
+extern "C" void * common_thread_routine(void * pv)
+{
+    abstract_thread * pt = static_cast<abstract_thread *>(pv);
+    pt->run();
+    delete pt;
+    return 0;
+}
+
+#endif
+
+//
+
+template<class F> class thread: public abstract_thread
+{
+public:
+
+    explicit thread(F f): f_(f)
+    {
+    }
+
+    void run()
+    {
+        f_();
+    }
+
+private:
+
+    F f_;
+};
+
+template<class F> pthread_t createThread(F f)
+{
+    std::auto_ptr<abstract_thread> p(new thread<F>(f));
+
+    pthread_t r;
+
+    if(pthread_create(&r, 0, common_thread_routine, p.get()) == 0)
+    {
+        p.release();
+        return r;
+    }
+
+    throw std::runtime_error("createThread failed.");
+}
+
+//
+
+int const n = 1024 * 1024;
+
+void test(boost::shared_ptr<int> const & pi)
+{
+    std::vector< boost::shared_ptr<int> > v;
+
+    for(int i = 0; i < n; ++i)
+    {
+        v.push_back(pi);
+    }
+}
+
+int const m = 16; // threads
+
+#if defined(BOOST_LWM_USE_CRITICAL_SECTION)
+    char const * implementation = "critical section";
+#elif defined(BOOST_LWM_USE_PTHREADS)
+    char const * implementation = "pthread_mutex";
+#else
+    char const * implementation = "spinlock";
+#endif
+
+int main()
+{
+    std::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();
+
+    pthread_t a[m];
+
+    for(int i = 0; i < m; ++i)
+    {
+        a[i] = createThread( boost::bind(test, pi) );
+    }
+
+    for(int i = 0; i < m; ++i)
+    {
+        pthread_join(a[i], 0);
+    }
+
+    t = std::clock() - t;
+
+    std::printf("\n\n%.3f seconds.\n", static_cast<double>(t) / CLOCKS_PER_SEC);
+
+    return 0;
+}
--- a/shared_ptr_test.cpp
+++ b/shared_ptr_test.cpp
@@ -0,0 +1,372 @@
+#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#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_ptr_test.cpp - a test for shared_ptr.hpp and weak_ptr.hpp
+//
+//  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.
+//
+
+#include <boost/detail/lightweight_test.hpp>
+
+#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;
+}
+
+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
+    {
+        return 1;
+    }
+
+private:
+
+    X(X const &);
+    X & operator= (X const &);
+};
+
+struct Y: public X
+{
+    Y()
+    {
+        ++cnt;
+        std::cout << "Y(" << this << ")::Y()\n";
+    }
+
+    ~Y()
+    {
+        --cnt;
+        std::cout << "Y(" << this << ")::~Y()\n";
+    }
+
+    virtual int id() const
+    {
+        return 2;
+    }
+
+private:
+
+    Y(Y const &);
+    Y & operator= (Y const &);
+};
+
+int * get_object()
+{
+    ++cnt;
+    std::cout << "get_object()\n";
+    return &cnt;
+}
+
+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);
+    BOOST_TEST((*p).id() == 1);
+}
+
+template<class T> void test_is_X(boost::weak_ptr<T> const & p)
+{
+    BOOST_TEST(p.get() != 0);
+    BOOST_TEST(p.get()->id() == 1);
+}
+
+template<class T> void test_is_Y(boost::shared_ptr<T> const & p)
+{
+    BOOST_TEST(p->id() == 2);
+    BOOST_TEST((*p).id() == 2);
+}
+
+template<class T> void test_is_Y(boost::weak_ptr<T> const & p)
+{
+    BOOST_TEST(p.get() != 0);
+    BOOST_TEST(p.get()->id() == 2);
+}
+
+template<class T> void test_eq(T const & a, T const & b)
+{
+    BOOST_TEST(a == b);
+    BOOST_TEST(!(a != b));
+    BOOST_TEST(!(a < b));
+    BOOST_TEST(!(b < a));
+}
+
+template<class T> void test_ne(T const & a, T const & b)
+{
+    BOOST_TEST(!(a == b));
+    BOOST_TEST(a != 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);
+    BOOST_TEST(!(a != b));
+}
+
+template<class T, class U> void test_ne2(T const & a, U const & b)
+{
+    BOOST_TEST(!(a == b));
+    BOOST_TEST(a != b);
+}
+
+template<class T> void test_is_zero(boost::shared_ptr<T> const & p)
+{
+    BOOST_TEST(!p);
+    BOOST_TEST(p.get() == 0);
+}
+
+template<class T> void test_is_nonzero(boost::shared_ptr<T> const & p)
+{
+    // p? true: false is used to test p in a boolean context.
+    // BOOST_TEST(p) is not guaranteed to test the conversion,
+    // as the macro might test !!p instead.
+    BOOST_TEST(p? true: false);
+    BOOST_TEST(p.get() != 0);
+}
+
+int main()
+{
+    using namespace boost;
+
+    {
+        shared_ptr<X> p(new Y);
+        shared_ptr<X> p2(new X);
+
+        test_is_nonzero(p);
+        test_is_nonzero(p2);
+        test_is_Y(p);
+        test_is_X(p2);
+        test_ne(p, p2);
+
+        {
+            shared_ptr<X> q(p);
+            test_eq(p, q);
+        }
+
+        shared_ptr<Y> p3 = shared_dynamic_cast<Y>(p);
+        shared_ptr<Y> p4 = shared_dynamic_cast<Y>(p2);
+
+        test_is_nonzero(p3);
+        test_is_zero(p4);
+
+        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);
+        test_ne2(p2, p4);
+
+        shared_ptr<void> p5(p);
+
+        test_is_nonzero(p5);
+        test_eq2(p, p5);
+
+        std::cout << "--\n";
+
+        p.reset();
+        p2.reset();
+        p3.reset();
+        p4.reset();
+
+        test_is_zero(p);
+        test_is_zero(p2);
+        test_is_zero(p3);
+        test_is_zero(p4);
+
+        std::cout << "--\n";
+
+        BOOST_TEST(p5.use_count() == 1);
+
+        weak_ptr<X> wp1;
+
+        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 &)
+        {
+        }
+
+        test_is_zero(boost::make_shared(wp1));
+
+        weak_ptr<X> wp2 = shared_static_cast<X>(p5);
+
+        BOOST_TEST(wp2.use_count() == 1);
+        BOOST_TEST(wp2.get() != 0);
+        test_is_Y(wp2);
+        test_ne(wp1, wp2);
+
+        // Scoped to not affect the subsequent use_count() tests.
+        {
+            shared_ptr<X> sp2(wp2);
+            test_is_nonzero(boost::make_shared(wp2));
+        }
+
+        weak_ptr<Y> wp3 = shared_dynamic_cast<Y>(boost::make_shared(wp2));
+
+        BOOST_TEST(wp3.use_count() == 1);
+        BOOST_TEST(wp3.get() != 0);
+        test_eq2(wp2, wp3);
+
+        weak_ptr<X> wp4(wp3);
+
+        BOOST_TEST(wp4.use_count() == 1);
+        BOOST_TEST(wp4.get() != 0);
+        test_eq(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);
+
+        //
+
+        wp1 = p4;
+        wp1 = wp3;
+        wp1 = wp2;
+
+        BOOST_TEST(wp1.use_count() == 1);
+        BOOST_TEST(wp1.get() != 0);
+        test_eq(wp1, wp2);
+
+        weak_ptr<X> wp5;
+
+        bool b1 = wp1 < wp5;
+        bool b2 = wp5 < wp1;
+
+        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
+
+        BOOST_TEST(b1 == (wp1 < wp5));
+        BOOST_TEST(b2 == (wp5 < wp1));
+
+        {
+            // 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);
+
+    return boost::report_errors();
+}
--- a/shared_ptr_timing_test.cpp
+++ b/shared_ptr_timing_test.cpp
@@ -0,0 +1,41 @@
+#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#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_ptr_timing_test.cpp - use to evaluate the impact of thread safety
+//
+//  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.
+//
+
+#include <boost/shared_ptr.hpp>
+#include <iostream>
+#include <vector>
+#include <ctime>
+
+int const n = 8 * 1024 * 1024;
+
+int main()
+{
+    std::vector< boost::shared_ptr<int> > v;
+    boost::shared_ptr<int> pi(new int);
+
+    std::clock_t t = std::clock();
+
+    for(int i = 0; i < n; ++i)
+    {
+        v.push_back(pi);
+    }
+
+    t = std::clock() - t;
+
+    std::cout << static_cast<double>(t) / CLOCKS_PER_SEC << '\n';
+}
--- a/smart_ptr.htm
+++ b/smart_ptr.htm
@@ -1,155 +1,168 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-
 	<head>
+		<title>Smart Pointers</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Smart Pointer Classes</title>
 	</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Smart
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">Smart 
 			Pointers</h1>
-<p>Smart pointers are classes which store pointers to dynamically allocated
-(heap) objects.&nbsp; They behave much like built-in C++ pointers except that
-they automatically delete the object pointed to at the appropriate
-time.&nbsp;Smart pointers are particularly useful in the face of exceptions as
-they ensure proper destruction of dynamically allocated objects. They can also
-be used to keep track of dynamically allocated objects shared by multiple
-owners.</p>
-<p>Conceptually, smart pointers are seen as owning the object pointed to, and
-thus responsible for deletion of the object when it is no longer needed.</p>
-<p>The header <a href="../../boost/smart_ptr.hpp">boost/smart_ptr.hpp</a>
-provides four smart pointer template classes:</p>
+		<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 
+			pointers are particularly useful in the face of exceptions as they ensure 
+			proper destruction of dynamically allocated objects. They can also be used to 
+			keep track of dynamically allocated objects shared by multiple owners.</p>
+		<p>Conceptually, smart pointers are seen as owning the object pointed to, and thus 
+			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">
 				<tr>
-      <td>
-        <p align="left"><a href="scoped_ptr.htm"><strong>scoped_ptr</strong></a></td>
+					<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>
 					<td>Simple sole ownership of single objects. Noncopyable.</td>
 				</tr>
 				<tr>
-      <td><a href="scoped_array.htm"><strong>scoped_array</strong></a></td>
+					<td><a href="scoped_array.htm"><b>scoped_array</b></a></td>
+					<td><a href="../../boost/scoped_array.hpp">&lt;boost/scoped_array.hpp&gt;</a></td>
 					<td>Simple sole ownership of arrays. Noncopyable.</td>
 				</tr>
 				<tr>
-      <td><a href="shared_ptr.htm"><strong>shared_ptr</strong></a></td>
+					<td><a href="shared_ptr.htm"><b>shared_ptr</b></a></td>
+					<td><a href="../../boost/shared_ptr.hpp">&lt;boost/shared_ptr.hpp&gt;</a></td>
 					<td>Object ownership shared among multiple pointers</td>
 				</tr>
 				<tr>
-      <td><a href="shared_array.htm"><strong>shared_array</strong></a></td>
+					<td><a href="shared_array.htm"><b>shared_array</b></a></td>
+					<td><a href="../../boost/shared_array.hpp">&lt;boost/shared_array.hpp&gt;</a></td>
 					<td>Array ownership shared among multiple pointers.</td>
 				</tr>
+				<tr>
+					<td><a href="weak_ptr.htm"><b>weak_ptr</b></a></td>
+					<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>
 			</table>
 		</div>
-<p>These classes are designed to complement the C++ Standard Library <tt>auto_ptr</tt>
-class.</p>
-<p>They are examples of the &quot;resource acquisition is initialization&quot;
-idiom described in Bjarne Stroustrup's &quot;The C++ Programming Language&quot;,
-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 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>These smart pointer classes have a template parameter, <tt><b>T</b></tt>, which
-specifies the type of the object pointed to by the smart pointer.&nbsp; The
-behavior of all four classes is undefined if the destructor or operator delete
-for objects of type <tt><b>T</b></tt>  throw exceptions.</p>
-<p><code><b>T</b></code> may be an incomplete type at the point of smart pointer
-declaration.&nbsp; Unless otherwise specified, it is required that <code><b>T</b></code>
-be a complete type at points of smart pointer instantiation. Implementations are
-required to diagnose (treat as an error) all violations of this requirement,
-including deletion of an incomplete type. See <a href="../utility/utility.htm#checked_delete">checked_delete()</a>.</p>
+		<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 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>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>
+			for objects of type <b>T</b> throw exceptions.</p>
+		<p><b>T</b> may be an incomplete type at the point of smart pointer declaration. 
+			Unless otherwise specified, it is required that <b>T</b> be a complete type at 
+			points of smart pointer instantiation. Implementations are required to diagnose 
+			(treat as an error) all violations of this requirement, including deletion of 
+			an incomplete type. See the description of the <a href="../utility/utility.htm#checked_delete">
+				<b>checked_delete</b></a> function template.</p>
+		<P>Note that <STRONG>shared_ptr</STRONG> does not have this restriction, as most of 
+			its member functions do not require <STRONG>T</STRONG> to be a complete type.</P>
 		<h3>Rationale</h3>
-<p>The requirements on <tt><b>T</b></tt> are carefully crafted to maximize safety
-yet allow handle-body (also called pimpl) and similar idioms.&nbsp; In these idioms a
-smart pointer may appear in translation units where <tt><b>T</b></tt> is an
-incomplete type.&nbsp; This separates interface from implementation and hides
-implementation from translation units which merely use the interface.&nbsp;
-Examples described in the documentation for specific smart pointers illustrate
-use of smart pointers in these idioms.</p>
-<h2>Exception safety</h2>
-<p>Several functions in these smart pointer classes are specified as having
-&quot;no effect&quot; or &quot;no effect except such-and-such&quot; if an
-exception is thrown.&nbsp;&nbsp; This means that when an exception is thrown by
-an object of one of these classes, the entire program state remains the same as
-it was prior to the function call which resulted in the exception being
-thrown.&nbsp; This amounts to a guarantee that there are no detectable side
-effects.&nbsp;&nbsp; Other functions never throw exceptions. The only exception
-ever thrown by functions which do throw (assuming <tt>T</tt> meets the <a href="#Common requirements">Common
-requirements</a>)&nbsp; is <tt>std::bad_alloc</tt>, and that is thrown only by
-functions which are explicitly documented as possibly throwing <tt>std::bad_alloc</tt>.</p>
+		<p>The requirements on <b>T</b> are carefully crafted to maximize safety yet allow 
+			handle-body (also called pimpl) and similar idioms. In these idioms a smart 
+			pointer may appear in translation units where <b>T</b> is an incomplete type. 
+			This separates interface from implementation and hides implementation from 
+			translation units which merely use the interface. Examples described in the 
+			documentation for specific smart pointers illustrate use of smart pointers in 
+			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>
+		<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, 
+			the entire program state remains the same as it was prior to the function call 
+			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>, 
+			and that is thrown only by functions which are explicitly documented as 
+			possibly throwing <b>std::bad_alloc</b>.</p>
 		<h2>Exception-specifications</h2>
-<p>Exception-specifications are not used; see <a href="../../more/lib_guide.htm#Exception-specification">exception-specification
-rationale</a>.</p>
-<p>All four classes contain member functions which can never throw exceptions,
-because they neither throw exceptions themselves nor call other functions which
-may throw exceptions.&nbsp; These members are indicated by a comment: <kbd>//
-never throws</kbd>. </p>
+		<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 
+			exceptions, because they neither throw exceptions themselves nor call other 
+			functions which may throw exceptions. These members are indicated by a comment: <code>
+				// 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>
-<p>May, 2001. Vladimir Prus suggested requiring a complete type on
-destruction.&nbsp; Refinement evolved in discussions including Dave Abrahams,
-Greg Colvin, Beman Dawes, Rainer Deyke, Peter Dimov, John Maddock, Vladimir Prus,
-Shankar Sai, and others.</p>
-<p>November, 1999. Darin Adler provided operator ==, operator !=, and std::swap
-and std::less specializations for shared types.</p>
-<p>September, 1999. Luis Coelho provided shared_ptr::swap and shared_array::swap</p>
-<p>May, 1999.&nbsp; In April and May, 1999, Valentin Bonnard and David Abrahams
-made a number of suggestions resulting in numerous improvements.&nbsp; See the
-revision history in <a href="../../boost/smart_ptr.hpp"><tt>smart_ptr.hpp</tt></a>
-for the specific changes made as a result of their constructive criticism.</p>
-<p>Oct, 1998.&nbsp; In 1994 Greg Colvin proposed to the C++ Standards Committee
-classes named <strong>auto_ptr</strong> and <strong>counted_ptr</strong> which
-were very similar to what we now call <strong>scoped_ptr</strong> and <strong>shared_ptr</strong>.&nbsp;
-The committee document was 94-168/N0555, Exception Safe Smart Pointers.&nbsp; In
-one of the very few cases where the Library Working Group's recommendations were
-not followed by the full committee, <strong>counted_ptr</strong> was rejected
-and surprising transfer-of-ownership semantics were added to <strong>auto-ptr</strong>.</p>
-<p>Beman Dawes proposed reviving the original semantics under the names <strong>safe_ptr</strong>
-and <strong>counted_ptr</strong> at an October, 1998, meeting of Per Andersson,
-Matt Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis, Dietmar
-K<EFBFBD>hl, Nathan Myers, Chichiang Wan and Judy Ward.&nbsp; During the discussion,
-the four class names were finalized, it was decided that there was no need to
-exactly follow the <strong>std::auto_ptr</strong> interface, and various
-function signatures and semantics were finalized.</p>
-<p>Over the next three months, several implementations were considered for <strong>shared_ptr</strong>,
-and discussed on the <a href="http://www.boost.org">boost.org</a> mailing
-list.&nbsp; The implementation questions revolved around the reference count
-which must be kept, either attached to the pointed to object, or detached
-elsewhere. Each of those variants have themselves two major variants:
+			throwing exceptions by the <a href="#Common requirements">common requirements</a>.</p>
+		<h2>History 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 
+			changes.</p>
+		<p>May 2001. Vladimir Prus suggested requiring a complete type on destruction. 
+			Refinement evolved in discussions including Dave Abrahams, Greg Colvin, Beman 
+			Dawes, Rainer Deyke, Peter Dimov, John Maddock, Vladimir Prus, Shankar Sai, and 
+			others.</p>
+		<p>November 1999. Darin Adler provided <b>operator ==</b>, <b>operator !=</b>, and <b>std::swap</b>
+			and <b>std::less</b> specializations for shared types.</p>
+		<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 
+			Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis, Dietmar K<>hl, 
+			Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four 
+			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>
+		<p>Over the next three months, several implementations were considered for <b>shared_ptr</b>, 
+			and discussed on the <a href="http://www.boost.org">boost.org</a> mailing list. 
+			The implementation questions revolved around the reference count which must be 
+			kept, either attached to the pointed to object, or detached elsewhere. Each of 
+			those variants have themselves two major variants:
 			<ul>
-  <li>Direct detached: the shared_ptr contains a pointer to the object, and a
-    pointer to the count.</li>
-  <li>Indirect detached: the shared_ptr contains a pointer to a helper object,
-    which in turn contains a pointer to the object and the count.</li>
-  <li>Embedded attached: the count is a member of the object pointed to.</li>
-  <li>Placement attached: the count is attached via operator new manipulations.</li>
+				<li>
+				Direct detached: the shared_ptr contains a pointer to the object, and a pointer 
+				to the count.
+				<li>
+				Indirect detached: the shared_ptr contains a pointer to a helper object, which 
+				in turn contains a pointer to the object and the count.
+				<li>
+				Embedded attached: the count is a member of the object pointed to.
+				<li>
+					Placement attached: the count is attached via operator new manipulations.</li>
 			</ul>
-<p>Each implementation technique has advantages and disadvantages.&nbsp; We went
-so far as to run various timings of the direct and indirect approaches, and
-found that at least on Intel Pentium chips there was very little measurable
-difference.&nbsp; Kevlin Henney provided a paper he wrote on &quot;Counted Body
-Techniques.&quot;&nbsp; Dietmar K<EFBFBD>hl suggested an elegant partial template
-specialization technique to allow users to choose which implementation they
-preferred, and that was also experimented with.</p>
-<p>But Greg Colvin and Jerry Schwarz argued that &quot;parameterization will
-discourage users&quot;, and in the end we choose to supply only the direct
-implementation.</p>
-<p>See the Revision History section of the header for further contributors.</p>
+		<p>Each implementation technique has advantages and disadvantages. We went so far 
+			as to run various timings of the direct and indirect approaches, and found that 
+			at least on Intel Pentium chips there was very little measurable difference. 
+			Kevlin Henney provided a paper he wrote on "Counted Body Techniques." Dietmar 
+			K<EFBFBD>hl suggested an elegant partial template specialization technique to allow 
+			users to choose which implementation they preferred, and that was also 
+			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>
 		<hr>
-<p>Revised&nbsp; <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan
-->24 May 2001<!--webbot bot="Timestamp" endspan i-checksum="15110"
+		<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><EFBFBD> Copyright Greg Colvin and Beman Dawes 1999. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
-
+		<p>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>
--- a/smart_ptr_test.cpp
+++ b/smart_ptr_test.cpp
@@ -13,13 +13,22 @@
 //  20 Jul 99  header name changed to .hpp
 //  20 Apr 99  additional error tests added.

-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/smart_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/shared_array.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+
 #include <cstring>
 #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 )
@@ -48,7 +57,7 @@ class UDT {
  explicit UDT( long value=0 ) : value_(value) { ++UDT_use_count; }
  ~UDT() {
    --UDT_use_count;
-    cout << "UDT with value " << value_ << " being destroyed" << endl;
+    cout << "UDT with value " << value_ << " being destroyed\n";
    }
  long value() const { return value_; }
  void value( long v ) { value_ = v;; }
@@ -71,15 +80,14 @@ Incomplete * check_incomplete( shared_ptr<Incomplete>& incomplete,
                               shared_ptr<Incomplete>& i2 )
 {
  incomplete.swap(i2);
-  cout << incomplete.use_count() << " " << incomplete.unique() << endl;
+  cout << incomplete.use_count() << ' ' << incomplete.unique() << '\n';
  return incomplete.get();
 }
-//  main  --------------------------------------------------------------------//

 //  This isn't a very systematic test; it just hits some of the basics.

-int test_main( int, char ** ) {
-
+void test()
+{
    BOOST_TEST( UDT_use_count == 0 );  // reality check

    //  test scoped_ptr with a built-in type
@@ -186,12 +194,10 @@ int test_main( int, char ** ) {
    BOOST_TEST( *cp4 == 87654 );
    BOOST_TEST( cp2.get() == 0 );

-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    set< shared_ptr<int> > scp;
    scp.insert(cp4);
    BOOST_TEST( scp.find(cp4) != scp.end() );
    BOOST_TEST( scp.find(cp4) == scp.find( shared_ptr<int>(cp4) ) );
-#endif

    //  test shared_array with a built-in type
    char * cap = new char [ 100 ];
@@ -232,12 +238,10 @@ int test_main( int, char ** ) {
    BOOST_TEST( strcmp( ca4.get(), "Not dog with mustard and relish" ) == 0 );
    BOOST_TEST( ca3.get() == 0 );

-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    set< shared_array<char> > sca;
    sca.insert(ca4);
    BOOST_TEST( sca.find(ca4) != sca.end() );
    BOOST_TEST( sca.find(ca4) == sca.find( shared_array<char>(ca4) ) );
-#endif

    //  test shared_array with user defined type
    shared_array<UDT> udta ( new UDT[3] );
@@ -280,10 +284,13 @@ int test_main( int, char ** ) {
    BOOST_TEST( sup.use_count() == 2 );
    BOOST_TEST( sup2.use_count() == 2 );

-  cout << "OK" << endl;
+    cout << "OK\n";

    new char[12345]; // deliberate memory leak to verify leaks detected
+}

-  return 0;
-  } // main
-
+int main()
+{
+    test();
+    return boost::report_errors();
+}
--- a/smarttests.htm
+++ b/smarttests.htm
@@ -1,13 +1,15 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
 <html>
+
 <head>
-<title>boost: smart pointer tests</title>
+<title>Smart Pointer Timings</title>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<!--
-->
+</head>
+
 <body bgcolor="#FFFFFF">

-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" WIDTH="277" HEIGHT="86">Smart
-Pointers Timings </h1>
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 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 
@@ -20,7 +22,8 @@ Pointers Timings </h1>
  a guide for current and future investigations into smart pointer implementation 
  strategies.</p>
 <p>Thanks are due to <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>,
-<a href="../../people/gavin_collings.htm"> Gavin Collings</a>, <a href="../../people/greg_colvin.htm"> Greg Colvin</a> and
+Gavin Collings,
+<a href="../../people/greg_colvin.htm">Greg Colvin</a> and
 <a href="../../people/beman_dawes.html">Beman Dawes</a> 
  for test code and trial implementations, the final version of which can be found 
  in .zip format <a href="smarttest.zip">here</a>.</p>
@@ -75,7 +78,7 @@ Pointers Timings </h1>
  </tr>
  <tr> 
    <td width="20">&nbsp; </td>
-    <td><img src="msvcspeed.gif" width="560" height="355"></td>
+    <td><img src="msvcspeed.gif" width="560" height="355" alt="MSVC speed graph"></td>
    <td width="20">&nbsp;</td>
  </tr>
  <tr> 
@@ -85,7 +88,7 @@ Pointers Timings </h1>
  </tr>
  <tr> 
    <td>&nbsp;</td>
-    <td><img src="gccspeed.gif" width="560" height="355"></td>
+    <td><img src="gccspeed.gif" width="560" height="355" alt="GCC speed graph"></td>
    <td>&nbsp;</td>
  </tr>
  <tr> 
@@ -530,7 +533,7 @@ Pointers Timings </h1>
    spreads its information as in the case of linked pointer.</li>
 </ul>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->27 Jul 2000<!--webbot bot="Timestamp" endspan i-checksum="14992" -->
+<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->19 August 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
 </p>
 <p><EFBFBD> Copyright Gavin Collings 2000. Permission to copy, use, modify, sell
 and distribute this document is granted provided this copyright notice appears in all
--- a/weak_ptr.htm
+++ b/weak_ptr.htm
@@ -0,0 +1,258 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+	<head>
+		<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 
+			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>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>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));
+weak_ptr&lt;int&gt; q(p);
+
+// some time later
+
+if(int * r = q.get())
+{
+    // use *r
+}
+</pre>
+		<P>Imagine that after the <STRONG>if</STRONG>, but immediately before <STRONG>r</STRONG>
+			is used, another thread executes the statement <code>p.reset()</code>. Now <STRONG>r</STRONG>
+			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));
+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))
+{
+    // 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>
+		<h2><a name="Synopsis">Synopsis</a></h2>
+		<pre>namespace boost {
+
+  template&lt;typename T&gt; class weak_ptr {
+
+    public:
+      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="#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
+
+      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
+
+      void <a href="#reset">reset</a>();
+      T * <a href="#get">get</a>() const; // never throws; deprecated, will disappear
+
+      long <a href="#use_count">use_count</a>() const; // never throws
+      bool <a href="#expired">expired</a>() const; // never throws
+
+      void <a href="#swap">swap</a>(weak_ptr&lt;T&gt; &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, 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
+
+}
+</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> 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>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>
+			<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>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>
+		<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>
+		<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="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>
+		<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>
+		<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>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>
+		</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>
+		<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>
+		<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>
+		</A>
+	</body>
+</html>
Author	SHA1	Message	Date
nobody	9fa591db1f	This commit was manufactured by cvs2svn to create tag 'Version_1_29_0'. [SVN r15904]	2002-10-11 15:17:55 +00:00
Peter Dimov	71a0c0ee97	Fixes, notes. [SVN r15487]	2002-09-23 13:32:54 +00:00
nobody	4990c9c83e	This commit was manufactured by cvs2svn to create branch 'RC_1_29_0'. [SVN r15460]	2002-09-19 20:49:39 +00:00
Peter Dimov	9dcbc46225	Minor fix [SVN r15437]	2002-09-18 13:00:38 +00:00
Peter Dimov	024f918b86	More documentation fixes reflecting Dave Abrahams' comments [SVN r15411]	2002-09-17 13:59:17 +00:00
Peter Dimov	0f05f41306	Documentation fixes (reflecting Dave Abrahams' comments) [SVN r15382]	2002-09-16 15:26:52 +00:00
Peter Dimov	4ea6decc7d	scoped_ptr::reset changed to copy+swap (problem reported by Thomas Witt) [SVN r15239]	2002-09-09 17:44:33 +00:00
Peter Dimov	f79b8cb7ae	Tabs removed. [SVN r15175]	2002-09-06 12:50:02 +00:00
Peter Dimov	275cb77378	Fixed broken links. [SVN r15123]	2002-08-31 13:04:52 +00:00
Peter Dimov	b916445dd8	weak_ptr documentation updates; get() declared deprecated. [SVN r15111]	2002-08-29 15:18:04 +00:00
Douglas Gregor	c02fee7013	*_ptr.hpp: - Revert addition of is_pointerlike_helper weak_ptr.hpp: - Revert addition of get_pointer [SVN r15108]	2002-08-29 13:49:05 +00:00
Douglas Gregor	e77889679f	intrusive_ptr.hpp: scoped_ptr.hpp: - include <boost/type_traits/ice.hpp> [SVN r15104]	2002-08-27 13:33:22 +00:00
Douglas Gregor	b9dceb2340	*_ptr.hpp: - Added detail::is_pointerlike_helper function templates for Signals weak_ptr.hpp: - Added get_pointer function template for weak_ptr [SVN r15099]	2002-08-26 15:27:23 +00:00
John Maddock	e84eb3f1ba	Added #pragma's to fix codeguard errors. [SVN r14984]	2002-08-20 11:08:11 +00:00
Peter Dimov	92999be436	Corrected the shared_ptr(auto_ptr<Y> &) postcondition (reported by Maciej Sobczak) [SVN r14953]	2002-08-19 16:23:07 +00:00
Peter Dimov	bd4f575567	HPUX 10.20 patch (problem reported by Tom Matelich) [SVN r14943]	2002-08-17 13:33:41 +00:00
Peter Dimov	09016db3c3	Note added to shared_ptr(Y*, D). [SVN r14942]	2002-08-17 13:05:25 +00:00
Peter Dimov	c2ee5172b0	Switched to <boost/detail/lightweight_test.hpp> for testing. [SVN r14932]	2002-08-16 16:41:16 +00:00
Peter Dimov	8436c4d271	#pragma option -pc around use_count_is_zero added for Borland 5.5.1, to enable compilation with -ps set. [SVN r14927]	2002-08-16 15:55:19 +00:00
Peter Dimov	a09c2e556f	BOOST_NO_EXCEPTIONS support added. [SVN r14835]	2002-08-14 12:27:22 +00:00
Peter Dimov	e650c7ff16	Changed BOOST_TEST(p) to BOOST_TEST(p? true: false) to make sure the right thing is being tested. [SVN r14834]	2002-08-14 11:59:13 +00:00
Peter Dimov	c06b4206f2	#include <iostream> added. [SVN r14813]	2002-08-13 15:58:12 +00:00
Peter Dimov	89435a6287	get_pointer added. [SVN r14628]	2002-07-27 16:02:26 +00:00
Peter Dimov	5328674c2d	Minor scoped_* fix (px -> ptr) (Thanks to Bertolt Mildner) [SVN r14619]	2002-07-26 14:18:21 +00:00
Peter Dimov	927fe73093	Changed #ifdefs so that member templates aren't disabled by an empty config.hpp. [SVN r14589]	2002-07-24 15:36:25 +00:00
Peter Dimov	053aa108e3	Tabs. Grrr. [SVN r14588]	2002-07-24 14:14:17 +00:00
Peter Dimov	b5e5c35696	Minor updates. [SVN r14580]	2002-07-24 10:20:30 +00:00
Peter Dimov	77ad156c52	Design notes updated. [SVN r14575]	2002-07-23 19:12:40 +00:00
Peter Dimov	018c401e47	Best practices section, thread safety section, design notes added. [SVN r14572]	2002-07-23 15:19:22 +00:00
Peter Dimov	f586d3f83e	shared_ptr<void const> support added. [SVN r14570]	2002-07-23 12:33:11 +00:00
Peter Dimov	3f0ebd4c71	'shared_from_this' added. [SVN r14561]	2002-07-22 16:36:52 +00:00
Peter Dimov	33077bda71	Win64 patch (Tim Fenders) [SVN r14537]	2002-07-19 20:06:35 +00:00
Peter Dimov	547888d507	Consistent 'bool' conversions; scoped_ptr(auto_ptr); get_pointer(scoped_ptr) added. [SVN r14496]	2002-07-17 15:15:39 +00:00
Peter Dimov	af6fe18c9d	Minor fixes. [SVN r14464]	2002-07-15 12:52:29 +00:00
Peter Dimov	dca9628be3	Disabled some Borland warnings (David B. Held) [SVN r14368]	2002-07-09 12:06:46 +00:00
Peter Dimov	d84fa738ef	Sleep(0) changed to Sleep(1) to (hopefully) avoid livelocks. [SVN r14226]	2002-06-22 15:55:01 +00:00
Peter Dimov	a322dc54dc	Platform-specific spinlocks disabled by default unless BOOST_LWM_USE_SPINLOCK is defined. [SVN r14213]	2002-06-20 15:16:03 +00:00
Peter Dimov	951c2b7e83	counted_base is now smaller [SVN r14212]	2002-06-20 14:56:10 +00:00
Peter Dimov	23f68a5657	Added libstdc++ v3 specific lightweight_mutex and atomic_count (contributed by Lars Gullik Bjønnes) [SVN r13999]	2002-05-21 16:48:20 +00:00
Peter Dimov	ecb0b4478b	Typo fixed. [SVN r13770]	2002-05-09 11:16:29 +00:00
Peter Dimov	70255d46bb	Documented templated pointer constructors, revised the intro a bit. [SVN r13665]	2002-05-04 14:27:21 +00:00
Peter Dimov	4653c3673b	shared_ptr now autodetects counted_bases; minor test updates; intrusive_ptr no longer calls addref/release for NULL pointers. [SVN r13602]	2002-05-01 11:22:22 +00:00
Peter Dimov	11eacab70e	Made shared_ptr::share_ptr(Y * p) a member template. [SVN r13551]	2002-04-23 14:56:42 +00:00
Peter Dimov	110c0021e2	counted_base default constructor added [SVN r13542]	2002-04-22 18:01:19 +00:00
Peter Dimov	4c5e355a0b	Bugfixes. [SVN r13541]	2002-04-22 09:37:08 +00:00
Peter Dimov	fbc9028313	intrusive_ptr.hpp added (still experimental) [SVN r13526]	2002-04-19 19:34:16 +00:00
Peter Dimov	9b800d4f84	Added more mem_fn, shared_ptr tests. [SVN r13432]	2002-04-10 16:04:53 +00:00
Peter Dimov	513752eee5	Worked around an MSVC 6 bug (Markus Schoepflin) [SVN r13430]	2002-04-10 14:12:12 +00:00
Beman Dawes	9eb1ba7e9f	test_main args must be [] not * for new rev of test tools [SVN r13381]	2002-04-06 21:44:37 +00:00
Peter Dimov	fb5b1a20d2	Small modifications. [SVN r13212]	2002-03-15 22:03:56 +00:00
Peter Dimov	b89945d36a	Added winapi.hpp and a CRITICAL_SECTION lightweight_mutex variant. [SVN r13211]	2002-03-15 22:00:10 +00:00
Peter Dimov	220f35a0f1	Casts removed as unsafe, added intro paragraph about make_shared. [SVN r13180]	2002-03-12 14:39:22 +00:00
Peter Dimov	72f83165e0	Removed casts as unsafe. [SVN r13179]	2002-03-12 14:02:38 +00:00
Peter Dimov	c17f8c36c1	weak_ptr::expired() added; weak_ptr documentation updated. [SVN r13141]	2002-03-08 16:56:16 +00:00
Peter Dimov	8e604a9da9	Disabled the linux-specific versions since using kernel headers is problematic. #define BOOST_USE_ASM_ATOMIC_H to get them back. [SVN r12995]	2002-03-01 16:17:08 +00:00
Darin Adler	3e0233a26c	Minor text updates in history section. [SVN r12956]	2002-02-27 17:03:30 +00:00
Peter Dimov	aa98e2b37e	Added lwm_irix.hpp (contributed by Dan Gohman) [SVN r12955]	2002-02-27 16:35:15 +00:00
Peter Dimov	7b53c0040c	More output. [SVN r12852]	2002-02-18 12:39:32 +00:00
Peter Dimov	e6605637f8	BOOST_LWM_WIN32_USE_CRITICAL_SECTION option. [SVN r12842]	2002-02-16 18:45:20 +00:00
Peter Dimov	6dfe0896e3	Untabified. [SVN r12838]	2002-02-16 16:14:16 +00:00
Peter Dimov	9f295cbb48	Threaded test added. [SVN r12837]	2002-02-16 16:09:08 +00:00
Peter Dimov	76c19e6111	Enabled lwm_linux.hpp in lightweight_mutex.hpp. [SVN r12834]	2002-02-16 15:00:55 +00:00
Peter Dimov	6e6a2a013a	Added lwm_linux.hpp [SVN r12833]	2002-02-16 14:34:34 +00:00
Peter Dimov	2482e00224	Modified scoped_* to use checked_delete; HP aCC doesn't like the inline assertions. [SVN r12832]	2002-02-16 13:23:01 +00:00
Peter Dimov	7981b647c3	lwm_nop fixed to not emit warnings on g++; locking code #ifdef'ed since compilers sometimes have trouble removing it. [SVN r12822]	2002-02-15 18:07:42 +00:00
Peter Dimov	875bab352c	Added a timing test for the single/multi threaded perf ratio (~2:1) [SVN r12821]	2002-02-15 18:06:17 +00:00
Peter Dimov	862dc0001f	Documented the bool conversion. [SVN r12817]	2002-02-15 14:46:53 +00:00
Peter Dimov	adc3ec3851	Fixes. [SVN r12816]	2002-02-15 14:19:30 +00:00
Peter Dimov	5a6cd1cf3e	Added a default constructor to shared_count and shared_ptr for incomplete types (void). [SVN r12815]	2002-02-15 13:31:58 +00:00
Douglas Gregor	5e2f514140	Added forward declaration of 'weak_count' class, which is referenced in shared_count; the friend declaration does not suffice to forward-declare the name. [SVN r12813]	2002-02-14 23:08:30 +00:00
Peter Dimov	309e6dd82e	Revised to match the style of the C++ standard. [SVN r12806]	2002-02-14 17:12:07 +00:00
Peter Dimov	6c5d296722	Modified weak_ptr to reflect list comments. [SVN r12793]	2002-02-13 13:16:15 +00:00
Peter Dimov	b1a1ab99aa	Bug fixes. [SVN r12787]	2002-02-12 20:38:31 +00:00
Peter Dimov	1b69c14f45	weak_ptr made thread safe, shared->weak conversions, lightweight_mutex added. [SVN r12786]	2002-02-12 16:55:25 +00:00
Darin Adler	cd8dea78e6	Don't reinclude, since everything we need to include is already taken care of by <boost/shared_ptr.hpp>. [SVN r12776]	2002-02-09 17:18:38 +00:00
Peter Dimov	d77b35f333	Fix the g++ 2.9x operator!= ambiguity. [SVN r12772]	2002-02-09 15:45:29 +00:00
Peter Dimov	6f7b927641	weak_ptr::operator< is now stable, shared_ptr_test has much better coverage. [SVN r12769]	2002-02-09 12:34:05 +00:00
Darin Adler	d2e20cf56c	Remove obsolete paragraph [SVN r12767]	2002-02-09 02:54:00 +00:00
Darin Adler	a6126b1370	Fixed some broken internal links. [SVN r12766]	2002-02-09 01:18:00 +00:00
Peter Dimov	87f0accb23	Minor fixes. [SVN r12763]	2002-02-08 20:45:04 +00:00
Darin Adler	7add76dae8	Always say "private noncopyable" to avoid warnings. [SVN r12762]	2002-02-08 20:08:15 +00:00
Peter Dimov	2a2f10fddd	Borland 5.5.1 fix [SVN r12761]	2002-02-08 18:40:49 +00:00
Darin Adler	0dd3285d56	New casts for smart pointers. [SVN r12743]	2002-02-06 19:42:04 +00:00
Darin Adler	f9782387d9	Tweaks. [SVN r12715]	2002-02-04 22:52:48 +00:00
Peter Dimov	e1567707b1	Tab removed :-) [SVN r12701]	2002-02-04 19:45:11 +00:00
Beman Dawes	08df55159b	Fix broken links [SVN r12697]	2002-02-04 18:51:16 +00:00
Peter Dimov	c29cc62d66	Minor tweaks. [SVN r12684]	2002-02-04 11:15:40 +00:00
Darin Adler	6ed07733cb	Fix atomic_count.hpp includes, convert Macintosh newlines to Unix ones, since Metrowerks supports either and the rest of Boost uses Unix ones. [SVN r12683]	2002-02-04 08:00:20 +00:00
Darin Adler	ee3d3bd1e1	Mention thread safety feature. [SVN r12676]	2002-02-03 17:50:11 +00:00
Darin Adler	758954a93f	Documentation updates. [SVN r12675]	2002-02-03 17:46:08 +00:00
Douglas Gregor	590757e2b2	Don't give default arguments to function parameters what subsequent parameters do not have default arguments [SVN r12670]	2002-02-03 15:21:41 +00:00
Douglas Gregor	ddd6d54426	Need to include utility.hpp to get noncopyable [SVN r12669]	2002-02-03 15:19:04 +00:00
Darin Adler	1a7cd887e4	New smart pointer documentation. Related clean-up of the smart pointer library. Changing includes to include the new individual smart pointer headers. Replacing old smart pointer library with an include of the new smart pointer headers. Simplify ifdefs that involve the member templates macros now that BOOST_MSVC6_MEMBER_TEMPLATES is also guaranteed to bet set for platforms that have full member templates. [SVN r12647]	2002-02-02 18:36:12 +00:00
Peter Dimov	d3c76575f9	templated copy constructor added. [SVN r12644]	2002-02-02 16:19:45 +00:00
Peter Dimov	b224270cc0	auto_ptr& constructor now has no effects when exception is thrown [SVN r12643]	2002-02-02 16:18:04 +00:00
Peter Dimov	8b5b780c2c	better weak_ptr coverage [SVN r12624]	2002-02-01 19:34:31 +00:00
Peter Dimov	39c10f739d	added an auto_ptr & constructor to shared_count [SVN r12623]	2002-02-01 18:40:35 +00:00
Darin Adler	4fdc84f29e	Make the non-threads version work. [SVN r12597]	2002-01-31 06:52:58 +00:00
Peter Dimov	a8efe20862	Comments added. [SVN r12510]	2002-01-25 16:10:26 +00:00
Peter Dimov	58c5711b47	Added tests for the new smart pointers. [SVN r12500]	2002-01-25 13:54:30 +00:00
Darin Adler	5d564a2f01	Add a self-assignment assert to reset(). Also add an overload of reset to allow resetting to a new pointer with a new deletion function. [SVN r12491]	2002-01-24 19:16:12 +00:00
Peter Dimov	09c1476063	Smart pointer enhancements, initial commit [SVN r12439]	2002-01-22 13:38:52 +00:00
Beman Dawes	f255439ece	add eof newline [SVN r12358]	2002-01-19 15:54:28 +00:00
Peter Dimov	b104e9ae78	smart_ptr.hpp less<> fixed, partial specialization enabled on Sun 5.3 [SVN r12334]	2002-01-17 12:46:45 +00:00
Beman Dawes	4f964ce6ad	Add FAQ: why no release() [SVN r12286]	2002-01-11 20:20:07 +00:00
Beman Dawes	11ec515378	Fix broken link [SVN r12285]	2002-01-11 16:15:09 +00:00
Beman Dawes	1a9b1dd123	1.25.0 Final runup [SVN r11315]	2001-10-01 15:54:23 +00:00
Beman Dawes	a93dfc1837	Fix broken hyperlink [SVN r10896]	2001-08-19 15:08:33 +00:00
Beman Dawes	c5846378ab	More FAQ entries added. [SVN r10605]	2001-07-13 16:32:34 +00:00
Beman Dawes	aea7d0c9c8	Add FAQ why use_count()? [SVN r10604]	2001-07-13 14:07:08 +00:00
Beman Dawes	65c3f2dc85	Add table of contents, improve the FAQ [SVN r10599]	2001-07-12 19:51:53 +00:00