diff --git a/compatibility.htm b/compatibility.htm
new file mode 100644
index 0000000..fb4d0a5
--- /dev/null
+++ b/compatibility.htm
@@ -0,0 +1,105 @@
+
+
+
+
+
+
+Smart Pointer Changes
+
+
+
+
+
Smart
+Pointer Changes
+
+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.
+
+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.
+
+Features Requiring Code Changes to Take Advantage
+
+
+
+- The smart pointer class templates now each have their own header file.
+For compatibility, the
+<boost/smart_ptr.hpp>
+header now includes the headers for the four classic smart pointer class templates.
+
+- The weak_ptr template was added.
+
+- The new shared_ptr and shared_array relax the requirement that the pointed-to object's
+destructor must be visible when instantiating the shared_ptr destructor.
+This makes it easier to have shared_ptr members in classes without explicit destructors.
+
+- A custom deallocator can be passed in when creating a shared_ptr or shared_array.
+
+- shared_static_cast and shared_dynamic_cast function templates are
+provided which work for shared_ptr and weak_ptr as static_cast and
+dynamic_cast do for pointers.
+
+- The self-assignment misfeature has been removed from shared_ptr::reset,
+although it is still present in scoped_ptr, and in std::auto_ptr.
+Calling reset with a pointer to the object that's already owned by the
+shared_ptr results in undefined behavior
+(an assertion, or eventually a double-delete if assertions are off).
+
+- The BOOST_SMART_PTR_CONVERSION feature has been removed.
+
+- shared_ptr<void> is now allowed.
+
+
+
+Features That Improve Robustness
+
+
+
+- The manipulation of use counts is now thread safe on Windows, Linux, and platforms
+that support pthreads. See the
+<boost/detail/atomic_count.hpp>
+file for details
+
+- 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 shared_ptr was a pointer to a sub-object
+of a class that did not have a virtual destructor.
+
+
+
+Implementation Details
+
+
+
+- Some bugs in the assignment operator implementations and in reset
+have been fixed by using the "copy and swap" idiom.
+
+- Assertions have been added to check preconditions of various functions;
+however, since these use the new
+<boost/assert.hpp>
+header, the assertions are disabled by default.
+
+- The partial specialization of std::less has been replaced by operator<
+overloads which accomplish the same thing without relying on undefined behavior.
+
+- The incorrect overload of std::swap has been replaced by boost::swap, which
+has many of the same advantages for generic programming but does not violate the C++ standard.
+
+
+
+
+
+Revised 1 February 2002
+
+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.
+
+
+
+
diff --git a/enable_shared_from_this.html b/enable_shared_from_this.html
new file mode 100644
index 0000000..8ff0a73
--- /dev/null
+++ b/enable_shared_from_this.html
@@ -0,0 +1,93 @@
+
+
+
+ Boost: enable_shared_from_this.hpp documentation
+
+
+
+
+
+ |
+
+ |
+
+ enable_shared_from_this.hpp
+ |
+
+
+ | |
+
+
+
+
+ The header <boost/enable_shared_from_this.hpp> defines
+ the class template enable_shared_from_this. It is used as a
+ base class that allows a shared_ptr to the current
+ object to be obtained from within a member function.
+
+ enable_shared_from_this<T> defines two member functions
+ called shared_from_this that return a shared_ptr<T>
+ and shared_ptr<T const>, depending on constness, to this.
+
+
+class Y: public enable_shared_from_this<Y>
+{
+public:
+
+ shared_ptr<Y> f()
+ {
+ return shared_from_this();
+ }
+}
+
+int main()
+{
+ shared_ptr<Y> p(new Y);
+ shared_ptr<Y> q = p->f();
+ assert(p == q);
+ assert(!(p < q || q < p)); // p and q must share ownership
+}
+
+
+
+namespace boost
+{
+
+template<class T> class enable_shared_from_this
+{
+public:
+
+ shared_ptr<T> shared_from_this();
+ shared_ptr<T const> shared_from_this() const;
+}
+
+}
+
+ template<class T> shared_ptr<T>
+ enable_shared_from_this<T>::shared_from_this();
+ template<class T> shared_ptr<T const>
+ enable_shared_from_this<T>::shared_from_this() const;
+
+
+ Requires: enable_shared_from_this<T> must be an
+ accessible base class of T. *this must be a subobject
+ of an instance t of type T . There must exist
+ at least one shared_ptr instance p that owns
+ t.
+
+
+ Returns: A shared_ptr<T> instance r that shares
+ ownership with p.
+
+
+ Postconditions: r.get() == this.
+
+
+
+
+ Copyright © 2002, 2003 by Peter Dimov. Permission to copy, use, modify, sell
+ and distribute this document is granted provided this copyright notice appears
+ in all copies. This document is provided "as is" without express or implied
+ warranty, and with no claim as to its suitability for any purpose.
+
+
diff --git a/example/scoped_ptr_example.cpp b/example/scoped_ptr_example.cpp
new file mode 100644
index 0000000..ea1917d
--- /dev/null
+++ b/example/scoped_ptr_example.cpp
@@ -0,0 +1,21 @@
+// Boost scoped_ptr_example implementation file -----------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "scoped_ptr_example.hpp"
+#include
+
+class example::implementation
+{
+ public:
+ ~implementation() { std::cout << "destroying implementation\n"; }
+};
+
+example::example() : _imp( new implementation ) {}
+
+void example::do_something() { std::cout << "did something\n"; }
+
+example::~example() {}
diff --git a/example/scoped_ptr_example.hpp b/example/scoped_ptr_example.hpp
new file mode 100644
index 0000000..2747121
--- /dev/null
+++ b/example/scoped_ptr_example.hpp
@@ -0,0 +1,27 @@
+// Boost scoped_ptr_example header file ------------------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include
+#include
+
+// The point of this example is to prove that even though
+// example::implementation is an incomplete type in translation units using
+// this header, scoped_ptr< implementation > is still valid because the type
+// is complete where it counts - in the inplementation translation unit where
+// destruction is actually instantiated.
+
+class example : private boost::noncopyable
+{
+ public:
+ example();
+ ~example();
+ void do_something();
+ private:
+ class implementation;
+ boost::scoped_ptr< implementation > _imp; // hide implementation details
+};
+
diff --git a/example/scoped_ptr_example_test.cpp b/example/scoped_ptr_example_test.cpp
new file mode 100644
index 0000000..e880d31
--- /dev/null
+++ b/example/scoped_ptr_example_test.cpp
@@ -0,0 +1,15 @@
+// Boost scoped_ptr_example_test main program -------------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "scoped_ptr_example.hpp"
+
+int main()
+{
+ example my_example;
+ my_example.do_something();
+ return 0;
+}
diff --git a/example/shared_ptr_example.cpp b/example/shared_ptr_example.cpp
new file mode 100644
index 0000000..04a564e
--- /dev/null
+++ b/example/shared_ptr_example.cpp
@@ -0,0 +1,93 @@
+// Boost shared_ptr_example.cpp --------------------------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+// Revision History
+// 21 May 01 Initial complete version (Beman Dawes)
+
+// The original code for this example appeared in the shared_ptr documentation.
+// Ray Gallimore pointed out that foo_set was missing a Compare template
+// argument, so would not work as intended. At that point the code was
+// turned into an actual .cpp file so it could be compiled and tested.
+
+#include
+#include
+#include
+#include
+#include
+
+// The application will produce a series of
+// objects of type Foo which later must be
+// accessed both by occurrence (std::vector)
+// and by ordering relationship (std::set).
+
+struct Foo
+{
+ Foo( int _x ) : x(_x) {}
+ ~Foo() { std::cout << "Destructing a Foo with x=" << x << "\n"; }
+ int x;
+ /* ... */
+};
+
+typedef boost::shared_ptr FooPtr;
+
+struct FooPtrOps
+{
+ bool operator()( const FooPtr & a, const FooPtr & b )
+ { return a->x > b->x; }
+ void operator()( const FooPtr & a )
+ { std::cout << a->x << "\n"; }
+};
+
+int main()
+{
+ std::vector foo_vector;
+ std::set foo_set; // NOT multiset!
+
+ FooPtr foo_ptr( new Foo( 2 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset( new Foo( 1 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset( new Foo( 3 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ foo_ptr.reset ( new Foo( 2 ) );
+ foo_vector.push_back( foo_ptr );
+ foo_set.insert( foo_ptr );
+
+ std::cout << "foo_vector:\n";
+ std::for_each( foo_vector.begin(), foo_vector.end(), FooPtrOps() );
+
+ std::cout << "\nfoo_set:\n";
+ std::for_each( foo_set.begin(), foo_set.end(), FooPtrOps() );
+ std::cout << "\n";
+
+// Expected output:
+//
+// foo_vector:
+// 2
+// 1
+// 3
+// 2
+//
+// foo_set:
+// 3
+// 2
+// 1
+//
+// Destructing a Foo with x=2
+// Destructing a Foo with x=1
+// Destructing a Foo with x=3
+// Destructing a Foo with x=2
+
+ return 0;
+}
+
diff --git a/example/shared_ptr_example2.cpp b/example/shared_ptr_example2.cpp
new file mode 100644
index 0000000..5f0d797
--- /dev/null
+++ b/example/shared_ptr_example2.cpp
@@ -0,0 +1,20 @@
+// Boost shared_ptr_example2 implementation file -----------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "shared_ptr_example2.hpp"
+#include
+
+class example::implementation
+{
+ public:
+ ~implementation() { std::cout << "destroying implementation\n"; }
+};
+
+example::example() : _imp( new implementation ) {}
+
+void example::do_something()
+ { std::cout << "use_count() is " << _imp.use_count() << "\n"; }
diff --git a/example/shared_ptr_example2.hpp b/example/shared_ptr_example2.hpp
new file mode 100644
index 0000000..1aa3ea8
--- /dev/null
+++ b/example/shared_ptr_example2.hpp
@@ -0,0 +1,29 @@
+// Boost shared_ptr_example2 header file -----------------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include
+
+// This example demonstrates the handle/body idiom (also called pimpl and
+// several other names). It separates the interface (in this header file)
+// from the implementation (in shared_ptr_example2.cpp).
+
+// Note that even though example::implementation is an incomplete type in
+// some translation units using this header, shared_ptr< implementation >
+// is still valid because the type is complete where it counts - in the
+// shared_ptr_example2.cpp translation unit where functions requiring a
+// complete type are actually instantiated.
+
+class example
+{
+public:
+ example();
+ void do_something();
+private:
+ class implementation;
+ boost::shared_ptr< implementation > _imp; // hide implementation details
+};
+
diff --git a/example/shared_ptr_example2_test.cpp b/example/shared_ptr_example2_test.cpp
new file mode 100644
index 0000000..e5d4d89
--- /dev/null
+++ b/example/shared_ptr_example2_test.cpp
@@ -0,0 +1,20 @@
+// Boost shared_ptr_example2_test main program ------------------------------//
+
+// Copyright Beman Dawes 2001.
+// See accompanying license for terms and conditions of use.
+
+// See http://www.boost.org/libs/smart_ptr for documentation.
+
+#include "shared_ptr_example2.hpp"
+
+int main()
+{
+ example a;
+ a.do_something();
+ example b(a);
+ b.do_something();
+ example c;
+ c = a;
+ c.do_something();
+ return 0;
+}
diff --git a/gccspeed.gif b/gccspeed.gif
new file mode 100644
index 0000000..d78c06b
Binary files /dev/null and b/gccspeed.gif differ
diff --git a/include/boost/detail/atomic_count.hpp b/include/boost/detail/atomic_count.hpp
new file mode 100644
index 0000000..da4fc69
--- /dev/null
+++ b/include/boost/detail/atomic_count.hpp
@@ -0,0 +1,114 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_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 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
+
+#ifndef BOOST_HAS_THREADS
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef long atomic_count;
+
+}
+
+}
+
+#elif defined(BOOST_USE_ASM_ATOMIC_H)
+# include
+#elif defined(BOOST_AC_USE_PTHREADS)
+# include
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+# include
+#elif defined(__GLIBCPP__)
+# include
+#elif defined(BOOST_HAS_PTHREADS)
+# define BOOST_AC_USE_PTHREADS
+# include
+#else
+
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+#error Unrecognized threading platform
+
+#endif
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
diff --git a/include/boost/detail/atomic_count_gcc.hpp b/include/boost/detail/atomic_count_gcc.hpp
new file mode 100644
index 0000000..c3d29a8
--- /dev/null
+++ 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ønnes
+//
+// 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
+
+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
diff --git a/include/boost/detail/atomic_count_linux.hpp b/include/boost/detail/atomic_count_linux.hpp
new file mode 100644
index 0000000..1a69cec
--- /dev/null
+++ 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 . 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
+
+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
diff --git a/include/boost/detail/atomic_count_pthreads.hpp b/include/boost/detail/atomic_count_pthreads.hpp
new file mode 100644
index 0000000..0f8c663
--- /dev/null
+++ 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
+
+//
+// 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
diff --git a/include/boost/detail/atomic_count_win32.hpp b/include/boost/detail/atomic_count_win32.hpp
new file mode 100644
index 0000000..c8a4681
--- /dev/null
+++ b/include/boost/detail/atomic_count_win32.hpp
@@ -0,0 +1,98 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/atomic_count_win32.hpp
+//
+// Copyright (c) 2001, 2002, 2003 Peter Dimov
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+
+#ifdef BOOST_USE_WINDOWS_H
+# include
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedIncrement(long volatile *);
+extern "C" long_type __cdecl _InterlockedDecrement(long volatile *);
+
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+
+inline long InterlockedIncrement(long volatile * lp)
+{
+ return _InterlockedIncrement(lp);
+}
+
+inline long InterlockedDecrement(long volatile* lp)
+{
+ return _InterlockedDecrement(lp);
+}
+
+#else // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement(long volatile *);
+extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement(long volatile *);
+
+#endif // _WIN64
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
+class atomic_count
+{
+public:
+
+ explicit atomic_count(long v): value_(v)
+ {
+ }
+
+ long operator++()
+ {
+ // Some older versions do not accept volatile
+ return InterlockedIncrement(const_cast(&value_));
+ }
+
+ long operator--()
+ {
+ return InterlockedDecrement(const_cast(&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
diff --git a/include/boost/detail/lightweight_mutex.hpp b/include/boost/detail/lightweight_mutex.hpp
new file mode 100644
index 0000000..9155940
--- /dev/null
+++ b/include/boost/detail/lightweight_mutex.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/lightweight_mutex.hpp - lightweight mutex
+//
+// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// typedef 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
+
+// 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.
+
+#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(BOOST_LWM_USE_CRITICAL_SECTION) && !defined(BOOST_LWM_USE_PTHREADS)
+# define BOOST_LWM_WIN32
+#endif
+
+#if !defined(BOOST_HAS_THREADS)
+# if defined(BOOST_LWM_WIN32)
+# include
+# else
+# include
+# endif
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H)
+# include
+#elif defined(BOOST_LWM_USE_CRITICAL_SECTION)
+# include
+#elif defined(BOOST_LWM_USE_PTHREADS)
+# include
+#elif defined(BOOST_LWM_WIN32)
+# include
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi)
+# include
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__)
+# include
+#elif defined(BOOST_HAS_PTHREADS)
+# define BOOST_LWM_USE_PTHREADS
+# include
+#else
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+# error Unrecognized threading platform
+#endif
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
diff --git a/include/boost/detail/lwm_gcc.hpp b/include/boost/detail/lwm_gcc.hpp
new file mode 100644
index 0000000..bf8a09a
--- /dev/null
+++ 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ønnes
+//
+// 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
+#include
+
+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
diff --git a/include/boost/detail/lwm_irix.hpp b/include/boost/detail/lwm_irix.hpp
new file mode 100644
index 0000000..6e5e57f
--- /dev/null
+++ b/include/boost/detail/lwm_irix.hpp
@@ -0,0 +1,74 @@
+#ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
+
+//
+// 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
+#include
+#include
+
+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
diff --git a/include/boost/detail/lwm_linux.hpp b/include/boost/detail/lwm_linux.hpp
new file mode 100644
index 0000000..e4c23c3
--- /dev/null
+++ b/include/boost/detail/lwm_linux.hpp
@@ -0,0 +1,85 @@
+#ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
+
+//
+// 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 . 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
+#include
+
+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
diff --git a/include/boost/detail/lwm_nop.hpp b/include/boost/detail/lwm_nop.hpp
new file mode 100644
index 0000000..fdc0a3d
--- /dev/null
+++ b/include/boost/detail/lwm_nop.hpp
@@ -0,0 +1,38 @@
+#ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_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
diff --git a/include/boost/detail/lwm_pthreads.hpp b/include/boost/detail/lwm_pthreads.hpp
new file mode 100644
index 0000000..79ea5a7
--- /dev/null
+++ b/include/boost/detail/lwm_pthreads.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_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
+
+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
diff --git a/include/boost/detail/lwm_win32.hpp b/include/boost/detail/lwm_win32.hpp
new file mode 100644
index 0000000..2228231
--- /dev/null
+++ b/include/boost/detail/lwm_win32.hpp
@@ -0,0 +1,123 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/lwm_win32.hpp
+//
+// Copyright (c) 2002, 2003 Peter Dimov
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+
+#ifdef BOOST_USE_WINDOWS_H
+# include
+#endif
+
+#ifdef __BORLANDC__
+# pragma warn -8027 // Functions containing while are not expanded inline
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedExchange(long volatile *, long);
+
+#pragma intrinsic(_InterlockedExchange)
+
+inline long InterlockedExchange(long volatile* lp, long l)
+{
+ return _InterlockedExchange(lp, l);
+}
+
+#else // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchange(long volatile *, long);
+
+#endif // _WIN64
+
+extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
+class lightweight_mutex
+{
+private:
+
+ 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( 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.
+
+ Sleep(1);
+ }
+ }
+
+ ~scoped_lock()
+ {
+ 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
diff --git a/include/boost/detail/lwm_win32_cs.hpp b/include/boost/detail/lwm_win32_cs.hpp
new file mode 100644
index 0000000..c4547de
--- /dev/null
+++ b/include/boost/detail/lwm_win32_cs.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/lwm_win32_cs.hpp
+//
+// Copyright (c) 2002, 2003 Peter Dimov
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+
+#ifdef BOOST_USE_WINDOWS_H
+# include
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+#ifndef BOOST_USE_WINDOWS_H
+
+struct CRITICAL_SECTION
+{
+ struct critical_section_debug * DebugInfo;
+ long LockCount;
+ long RecursionCount;
+ void * OwningThread;
+ void * LockSemaphore;
+#if defined(_WIN64)
+ unsigned __int64 SpinCount;
+#else
+ unsigned long SpinCount;
+#endif
+};
+
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(CRITICAL_SECTION *);
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
+class lightweight_mutex
+{
+private:
+
+ CRITICAL_SECTION cs_;
+
+ lightweight_mutex(lightweight_mutex const &);
+ lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+ lightweight_mutex()
+ {
+ InitializeCriticalSection(&cs_);
+ }
+
+ ~lightweight_mutex()
+ {
+ 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)
+ {
+ EnterCriticalSection(&m_.cs_);
+ }
+
+ ~scoped_lock()
+ {
+ LeaveCriticalSection(&m_.cs_);
+ }
+ };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED
diff --git a/include/boost/detail/lwm_win32_nt.hpp b/include/boost/detail/lwm_win32_nt.hpp
new file mode 100644
index 0000000..39e49e2
--- /dev/null
+++ b/include/boost/detail/lwm_win32_nt.hpp
@@ -0,0 +1,64 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/lwm_win32_nt.hpp
+//
+// Copyright (c) 2002, 2003 Peter Dimov
+//
+// 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.
+//
+// "No threads" version of lwm_win32.hpp; binary compatible but no-op.
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+ long l_;
+
+ lightweight_mutex(lightweight_mutex const &);
+ lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+ lightweight_mutex(): l_(0)
+ {
+ }
+
+ class scoped_lock;
+ friend class scoped_lock;
+
+ class scoped_lock
+ {
+ private:
+
+ scoped_lock(scoped_lock const &);
+ scoped_lock & operator=(scoped_lock const &);
+
+ public:
+
+ explicit scoped_lock(lightweight_mutex &)
+ {
+ }
+ };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
diff --git a/include/boost/detail/shared_array_nmt.hpp b/include/boost/detail/shared_array_nmt.hpp
new file mode 100644
index 0000000..8e9b727
--- /dev/null
+++ 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
+#include
+#include
+#include
+
+#include // for std::ptrdiff_t
+#include // for std::swap
+#include // for std::less
+#include // for std::bad_alloc
+
+namespace boost
+{
+
+template 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 & 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 inline bool operator==(shared_array const & a, shared_array const & b)
+{
+ return a.get() == b.get();
+}
+
+template inline bool operator!=(shared_array const & a, shared_array const & b)
+{
+ return a.get() != b.get();
+}
+
+template inline bool operator<(shared_array const & a, shared_array const & b)
+{
+ return std::less()(a.get(), b.get());
+}
+
+template void swap(shared_array & a, shared_array & b)
+{
+ a.swap(b);
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
diff --git a/include/boost/detail/shared_count.hpp b/include/boost/detail/shared_count.hpp
new file mode 100644
index 0000000..2d14179
--- /dev/null
+++ b/include/boost/detail/shared_count.hpp
@@ -0,0 +1,555 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// detail/shared_count.hpp
+//
+// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+
+#include
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
+#endif
+
+#include
+#include
+#include
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include
+#endif
+
+#include // std::auto_ptr, std::allocator
+#include // std::less
+#include // std::exception
+#include // std::bad_alloc
+#include // std::type_info in get_deleter
+#include // std::size_t
+
+#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
+{
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// The standard library that comes with Borland C++ 5.5.1
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option push -pc
+#endif
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+ virtual char const * what() const throw()
+ {
+ return "boost::bad_weak_ptr";
+ }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
+namespace detail
+{
+
+class sp_counted_base
+{
+private:
+
+ typedef detail::lightweight_mutex mutex_type;
+
+public:
+
+ sp_counted_base(): use_count_(1), weak_count_(1)
+ {
+ }
+
+ virtual ~sp_counted_base() // nothrow
+ {
+ }
+
+ // dispose() is called when use_count_ drops to zero, to release
+ // the resources managed by *this.
+
+ virtual void dispose() = 0; // nothrow
+
+ // destruct() is called when weak_count_ drops to zero.
+
+ virtual void destruct() // nothrow
+ {
+ delete this;
+ }
+
+ virtual void * get_deleter(std::type_info const & ti) = 0;
+
+ void add_ref_copy()
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ ++use_count_;
+ }
+
+ void add_ref_lock()
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr());
+ ++use_count_;
+ }
+
+ void release() // nothrow
+ {
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ long new_use_count = --use_count_;
+
+ if(new_use_count != 0) return;
+ }
+
+ dispose();
+ weak_release();
+ }
+
+ void weak_add_ref() // nothrow
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ ++weak_count_;
+ }
+
+ void weak_release() // nothrow
+ {
+ long new_weak_count;
+
+ {
+#if defined(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
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ return use_count_;
+ }
+
+private:
+
+ sp_counted_base(sp_counted_base const &);
+ sp_counted_base & operator= (sp_counted_base const &);
+
+ long use_count_; // #shared
+ long weak_count_; // #weak + (#shared != 0)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+ mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int)
+{
+ boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int)
+{
+ boost::sp_array_constructor_hook(px);
+}
+
+template void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int)
+{
+ boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int)
+{
+ boost::sp_array_destructor_hook(px);
+}
+
+template void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+# pragma option push -Vx-
+#endif
+
+template class sp_counted_base_impl: public sp_counted_base
+{
+private:
+
+ P ptr; // copy constructor must not throw
+ D del; // copy constructor must not throw
+
+ sp_counted_base_impl(sp_counted_base_impl const &);
+ sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+ typedef sp_counted_base_impl this_type;
+
+public:
+
+ // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+ sp_counted_base_impl(P p, D d): ptr(p), del(d)
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+ }
+
+ virtual void dispose() // nothrow
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+ del(ptr);
+ }
+
+ virtual void * get_deleter(std::type_info const & ti)
+ {
+ return ti == typeid(D)? &del: 0;
+ }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+ void * operator new(std::size_t)
+ {
+ return std::allocator().allocate(1, static_cast(0));
+ }
+
+ void operator delete(void * p)
+ {
+ std::allocator().deallocate(static_cast(p), 1);
+ }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+ void * operator new(std::size_t)
+ {
+ return quick_allocator::alloc();
+ }
+
+ void operator delete(void * p)
+ {
+ quick_allocator::dealloc(p);
+ }
+
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const weak_count_id = 0x298C38A4;
+
+#endif
+
+class weak_count;
+
+class shared_count
+{
+private:
+
+ sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ int id_;
+#endif
+
+ friend class weak_count;
+
+public:
+
+ shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ }
+
+ template shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+#ifndef BOOST_NO_EXCEPTIONS
+
+ try
+ {
+ pi_ = new sp_counted_base_impl(p, d);
+ }
+ catch(...)
+ {
+ d(p); // delete p
+ throw;
+ }
+
+#else
+
+ pi_ = new sp_counted_base_impl(p, d);
+
+ if(pi_ == 0)
+ {
+ d(p); // delete p
+ boost::throw_exception(std::bad_alloc());
+ }
+
+#endif
+ }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ // auto_ptr is special cased to provide the strong guarantee
+
+ template
+ explicit shared_count(std::auto_ptr & r): pi_(new sp_counted_base_impl< Y *, checked_deleter >(r.get(), checked_deleter()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ r.release();
+ }
+
+#endif
+
+ ~shared_count() // nothrow
+ {
+ if(pi_ != 0) pi_->release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ id_ = 0;
+#endif
+ }
+
+ shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->add_ref_copy();
+ }
+
+ explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+
+ shared_count & operator= (shared_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ if(tmp != 0) tmp->add_ref_copy();
+ if(pi_ != 0) pi_->release();
+ pi_ = tmp;
+
+ return *this;
+ }
+
+ void swap(shared_count & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ r.pi_ = pi_;
+ pi_ = tmp;
+ }
+
+ long use_count() const // nothrow
+ {
+ return pi_ != 0? pi_->use_count(): 0;
+ }
+
+ bool unique() const // nothrow
+ {
+ return 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()(a.pi_, b.pi_);
+ }
+
+ void * get_deleter(std::type_info const & ti) const
+ {
+ return pi_? pi_->get_deleter(ti): 0;
+ }
+};
+
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
+
+class weak_count
+{
+private:
+
+ sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ int id_;
+#endif
+
+ friend class shared_count;
+
+public:
+
+ weak_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(weak_count_id)
+#endif
+ {
+ }
+
+ weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->weak_add_ref();
+ }
+
+ weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->weak_add_ref();
+ }
+
+ ~weak_count() // nothrow
+ {
+ if(pi_ != 0) pi_->weak_release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ id_ = 0;
+#endif
+ }
+
+ weak_count & operator= (shared_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ if(tmp != 0) tmp->weak_add_ref();
+ if(pi_ != 0) pi_->weak_release();
+ pi_ = tmp;
+
+ return *this;
+ }
+
+ weak_count & operator= (weak_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ if(tmp != 0) tmp->weak_add_ref();
+ if(pi_ != 0) pi_->weak_release();
+ pi_ = tmp;
+
+ return *this;
+ }
+
+ void swap(weak_count & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ r.pi_ = pi_;
+ pi_ = tmp;
+ }
+
+ long use_count() const // nothrow
+ {
+ return pi_ != 0? pi_->use_count(): 0;
+ }
+
+ 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()(a.pi_, b.pi_);
+ }
+};
+
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+{
+ if(pi_ != 0)
+ {
+ pi_->add_ref_lock();
+ }
+ else
+ {
+ boost::throw_exception(boost::bad_weak_ptr());
+ }
+}
+
+} // 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
diff --git a/include/boost/detail/shared_ptr_nmt.hpp b/include/boost/detail/shared_ptr_nmt.hpp
new file mode 100644
index 0000000..14fbe65
--- /dev/null
+++ 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
+#include
+#include
+#include
+
+#ifndef BOOST_NO_AUTO_PTR
+# include // for std::auto_ptr
+#endif
+
+#include // for std::swap
+#include // for std::less
+#include // for std::bad_alloc
+
+namespace boost
+{
+
+template 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 & 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 & 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 & 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 inline bool operator==(shared_ptr const & a, shared_ptr const & b)
+{
+ return a.get() == b.get();
+}
+
+template inline bool operator!=(shared_ptr const & a, shared_ptr const & b)
+{
+ return a.get() != b.get();
+}
+
+template inline bool operator<(shared_ptr const & a, shared_ptr const & b)
+{
+ return std::less()(a.get(), b.get());
+}
+
+template void swap(shared_ptr & a, shared_ptr & b)
+{
+ a.swap(b);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template inline T * get_pointer(shared_ptr const & p)
+{
+ return p.get();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
diff --git a/include/boost/enable_shared_from_this.hpp b/include/boost/enable_shared_from_this.hpp
new file mode 100644
index 0000000..d3f8ab8
--- /dev/null
+++ b/include/boost/enable_shared_from_this.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+//
+// enable_shared_from_this.hpp
+//
+// Copyright (c) 2002 Peter Dimov
+//
+// 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.
+//
+// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//
+
+#include
+#include
+#include
+#include
+
+namespace boost
+{
+
+template class enable_shared_from_this
+{
+protected:
+
+ enable_shared_from_this()
+ {
+ }
+
+ enable_shared_from_this(enable_shared_from_this const &)
+ {
+ }
+
+ enable_shared_from_this & operator=(enable_shared_from_this const &)
+ {
+ return *this;
+ }
+
+ ~enable_shared_from_this()
+ {
+ }
+
+public:
+
+ shared_ptr shared_from_this()
+ {
+ shared_ptr p(_internal_weak_this);
+ BOOST_ASSERT(p.get() == this);
+ return p;
+ }
+
+ shared_ptr shared_from_this() const
+ {
+ shared_ptr p(_internal_weak_this);
+ BOOST_ASSERT(p.get() == this);
+ return p;
+ }
+
+ typedef T _internal_element_type; // for bcc 5.5.1
+ weak_ptr<_internal_element_type> _internal_weak_this;
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
diff --git a/include/boost/get_pointer.hpp b/include/boost/get_pointer.hpp
new file mode 100644
index 0000000..09091e4
--- /dev/null
+++ b/include/boost/get_pointer.hpp
@@ -0,0 +1,30 @@
+// Copyright Peter Dimov and David Abrahams 2002. Permission to copy,
+// use, modify, sell and distribute this software is granted provided
+// this copyright notice appears in all copies of the source. This
+// software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.
+#ifndef GET_POINTER_DWA20021219_HPP
+# define GET_POINTER_DWA20021219_HPP
+
+# include
+
+namespace boost {
+
+// get_pointer(p) extracts a ->* capable pointer from p
+
+template T * get_pointer(T * p)
+{
+ return p;
+}
+
+// get_pointer(shared_ptr const & p) has been moved to shared_ptr.hpp
+
+template T * get_pointer(std::auto_ptr const& p)
+{
+ return p.get();
+}
+
+
+} // namespace boost
+
+#endif // GET_POINTER_DWA20021219_HPP
diff --git a/include/boost/intrusive_ptr.hpp b/include/boost/intrusive_ptr.hpp
new file mode 100644
index 0000000..7db6dcf
--- /dev/null
+++ b/include/boost/intrusive_ptr.hpp
@@ -0,0 +1,273 @@
+#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.
+//
+
+#include
+
+#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
+#include
+
+#include // for std::less
+#include // for std::basic_ostream
+
+
+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 intrusive_ptr
+{
+private:
+
+ typedef intrusive_ptr this_type;
+
+public:
+
+ typedef T element_type;
+
+ intrusive_ptr(): p_(0)
+ {
+ }
+
+ intrusive_ptr(T * p, bool add_ref = true): p_(p)
+ {
+ if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_);
+ }
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+ template intrusive_ptr(intrusive_ptr 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_);
+ }
+
+ ~intrusive_ptr()
+ {
+ if(p_ != 0) intrusive_ptr_release(p_);
+ }
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+ template intrusive_ptr & operator=(intrusive_ptr 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;
+ }
+
+ T * get() const
+ {
+ return p_;
+ }
+
+ T & operator*() const
+ {
+ return *p_;
+ }
+
+ T * operator->() const
+ {
+ return p_;
+ }
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+ operator bool () const
+ {
+ return p_ != 0;
+ }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ typedef T * (this_type::*unspecified_bool_type)() const;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return p_ == 0? 0: &this_type::get;
+ }
+
+#else
+
+ typedef T * this_type::*unspecified_bool_type;
+
+ operator unspecified_bool_type () const
+ {
+ return p_ == 0? 0: &this_type::p_;
+ }
+
+#endif
+
+ // operator! is a Borland-specific workaround
+ bool operator! () const
+ {
+ return p_ == 0;
+ }
+
+ void swap(intrusive_ptr & rhs)
+ {
+ T * tmp = p_;
+ p_ = rhs.p_;
+ rhs.p_ = tmp;
+ }
+
+private:
+
+ T * p_;
+};
+
+template inline bool operator==(intrusive_ptr const & a, intrusive_ptr const & b)
+{
+ return a.get() == b.get();
+}
+
+template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b)
+{
+ return a.get() != b.get();
+}
+
+template inline bool operator==(intrusive_ptr const & a, T * b)
+{
+ return a.get() == b;
+}
+
+template inline bool operator!=(intrusive_ptr const & a, T * b)
+{
+ return a.get() != b;
+}
+
+template inline bool operator==(T * a, intrusive_ptr const & b)
+{
+ return a == b.get();
+}
+
+template inline bool operator!=(T * a, intrusive_ptr const & b)
+{
+ return a != b.get();
+}
+
+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+
+// Resolve the ambiguity between our op!= and the one in rel_ops
+
+template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b)
+{
+ return a.get() != b.get();
+}
+
+#endif
+
+template inline bool operator<(intrusive_ptr const & a, intrusive_ptr const & b)
+{
+ return std::less()(a.get(), b.get());
+}
+
+template void swap(intrusive_ptr & lhs, intrusive_ptr & rhs)
+{
+ lhs.swap(rhs);
+}
+
+// mem_fn support
+
+template T * get_pointer(intrusive_ptr const & p)
+{
+ return p.get();
+}
+
+template intrusive_ptr static_pointer_cast(intrusive_ptr const & p)
+{
+ return static_cast(p.get());
+}
+
+template intrusive_ptr const_pointer_cast(intrusive_ptr const & p)
+{
+ return const_cast(p.get());
+}
+
+template intrusive_ptr dynamic_pointer_cast(intrusive_ptr const & p)
+{
+ return dynamic_cast(p.get());
+}
+
+// operator<<
+
+#if defined(__GNUC__) && (__GNUC__ < 3)
+
+template std::ostream & operator<< (std::ostream & os, intrusive_ptr const & p)
+{
+ os << p.get();
+ return os;
+}
+
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template basic_ostream & operator<< (basic_ostream & os, intrusive_ptr const & p)
+# else
+template std::basic_ostream & operator<< (std::basic_ostream & os, intrusive_ptr const & p)
+# endif
+{
+ os << p.get();
+ return os;
+}
+
+#endif
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
diff --git a/include/boost/scoped_array.hpp b/include/boost/scoped_array.hpp
new file mode 100644
index 0000000..e5919a4
--- /dev/null
+++ b/include/boost/scoped_array.hpp
@@ -0,0 +1,136 @@
+#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.
+//
+// http://www.boost.org/libs/smart_ptr/scoped_array.htm
+//
+
+#include
+#include
+#include // in case ptrdiff_t not in std
+
+#include
+
+#include // for std::ptrdiff_t
+
+namespace boost
+{
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_array_constructor_hook(void * p);
+void sp_array_destructor_hook(void * p);
+
+#endif
+
+// scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
+// is guaranteed, either on destruction of the scoped_array or via an explicit
+// reset(). Use shared_array or std::vector if your needs are more complex.
+
+template class scoped_array // noncopyable
+{
+private:
+
+ T * ptr;
+
+ scoped_array(scoped_array const &);
+ scoped_array & operator=(scoped_array const &);
+
+ typedef scoped_array this_type;
+
+public:
+
+ typedef T element_type;
+
+ explicit scoped_array(T * p = 0) : ptr(p) // never throws
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ boost::sp_array_constructor_hook(ptr);
+#endif
+ }
+
+ ~scoped_array() // never throws
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ boost::sp_array_destructor_hook(ptr);
+#endif
+ boost::checked_array_delete(ptr);
+ }
+
+ void reset(T * p = 0) // never throws
+ {
+ BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
+ this_type(p).swap(*this);
+ }
+
+ 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"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+ operator bool () const
+ {
+ return ptr != 0;
+ }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ typedef T * (this_type::*unspecified_bool_type)() const;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return ptr == 0? 0: &this_type::get;
+ }
+
+#else
+
+ typedef T * this_type::*unspecified_bool_type;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return ptr == 0? 0: &this_type::ptr;
+ }
+
+#endif
+
+ bool operator! () const // never throws
+ {
+ return ptr == 0;
+ }
+
+ void swap(scoped_array & b) // never throws
+ {
+ T * tmp = b.ptr;
+ b.ptr = ptr;
+ ptr = tmp;
+ }
+
+};
+
+template inline void swap(scoped_array & a, scoped_array & b) // never throws
+{
+ a.swap(b);
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
diff --git a/include/boost/scoped_ptr.hpp b/include/boost/scoped_ptr.hpp
new file mode 100644
index 0000000..c36cace
--- /dev/null
+++ b/include/boost/scoped_ptr.hpp
@@ -0,0 +1,158 @@
+#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.
+//
+// http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
+//
+
+#include
+#include
+#include
+
+#ifndef BOOST_NO_AUTO_PTR
+# include // for std::auto_ptr
+#endif
+
+namespace boost
+{
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * p);
+void sp_scalar_destructor_hook(void * p);
+
+#endif
+
+// scoped_ptr mimics a built-in pointer except that it guarantees deletion
+// of the object pointed to, either on destruction of the scoped_ptr or via
+// an explicit reset(). scoped_ptr is a simple solution for simple needs;
+// use shared_ptr or std::auto_ptr if your needs are more complex.
+
+template class scoped_ptr // noncopyable
+{
+private:
+
+ T * ptr;
+
+ scoped_ptr(scoped_ptr const &);
+ scoped_ptr & operator=(scoped_ptr const &);
+
+ typedef scoped_ptr this_type;
+
+public:
+
+ typedef T element_type;
+
+ explicit scoped_ptr(T * p = 0): ptr(p) // never throws
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ boost::sp_scalar_constructor_hook(ptr);
+#endif
+ }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ explicit scoped_ptr(std::auto_ptr p): ptr(p.release()) // never throws
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ boost::sp_scalar_constructor_hook(ptr);
+#endif
+ }
+
+#endif
+
+ ~scoped_ptr() // never throws
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ boost::sp_scalar_destructor_hook(ptr);
+#endif
+ boost::checked_delete(ptr);
+ }
+
+ void reset(T * p = 0) // never throws
+ {
+ BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
+ 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"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+ operator bool () const
+ {
+ return ptr != 0;
+ }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ typedef T * (this_type::*unspecified_bool_type)() const;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return ptr == 0? 0: &this_type::get;
+ }
+
+#else
+ typedef T * this_type::*unspecified_bool_type;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return ptr == 0? 0: &this_type::ptr;
+ }
+
+#endif
+
+ bool operator! () const // never throws
+ {
+ return ptr == 0;
+ }
+
+ void swap(scoped_ptr & b) // never throws
+ {
+ T * tmp = b.ptr;
+ b.ptr = ptr;
+ ptr = tmp;
+ }
+};
+
+template inline void swap(scoped_ptr & a, scoped_ptr & b) // never throws
+{
+ a.swap(b);
+}
+
+// get_pointer(p) is a generic way to say p.get()
+
+template inline T * get_pointer(scoped_ptr const & p)
+{
+ return p.get();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
diff --git a/include/boost/shared_array.hpp b/include/boost/shared_array.hpp
new file mode 100644
index 0000000..5e943d9
--- /dev/null
+++ b/include/boost/shared_array.hpp
@@ -0,0 +1,176 @@
+#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 // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include
+#else
+
+#include
+#include
+
+#include
+#include
+
+#include // for std::ptrdiff_t
+#include // for std::swap
+#include // 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 class shared_array
+{
+private:
+
+ // Borland 5.5.1 specific workarounds
+ typedef checked_array_deleter deleter;
+ typedef shared_array 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 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 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"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+ operator bool () const
+ {
+ return px != 0;
+ }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ typedef T * (this_type::*unspecified_bool_type)() const;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return px == 0? 0: &this_type::get;
+ }
+
+#else
+
+ typedef T * this_type::*unspecified_bool_type;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return px == 0? 0: &this_type::px;
+ }
+
+#endif
+
+ bool operator! () const // never throws
+ {
+ return px == 0;
+ }
+
+ bool unique() const // never throws
+ {
+ return pn.unique();
+ }
+
+ long use_count() const // never throws
+ {
+ return pn.use_count();
+ }
+
+ void swap(shared_array & 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 inline bool operator==(shared_array const & a, shared_array