boost::shared_ptr -> std::shared_ptr

6 files changed, 0 insertions, 1435 deletions

diff --git a/src/boost/checked_delete.hpp b/src/boost/checked_delete.hpp
deleted file mode 100644
index d7f52122de..0000000000
--- a/src/boost/checked_delete.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
-#define BOOST_CHECKED_DELETE_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/checked_delete.hpp
-//
-//  Copyright (c) 1999, 2000, 2001, 2002 boost.org
-//  Copyright (c) 2002, 2003 Peter Dimov
-//  Copyright (c) 2003 Daniel Frey
-//  Copyright (c) 2003 Howard Hinnant
-//
-//  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/utility/checked_delete.html for documentation.
-//
-
-namespace boost
-{
-
-// verify that types are complete for increased safety
-
-template<class T> inline void checked_delete(T * x)
-{
-    // intentionally complex - simplification causes regressions
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
-    delete x;
-}
-
-template<class T> inline void checked_array_delete(T * x)
-{
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
-    delete [] x;
-}
-
-template<class T> struct checked_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        // boost:: disables ADL
-        boost::checked_delete(x);
-    }
-};
-
-template<class T> struct checked_array_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        boost::checked_array_delete(x);
-    }
-};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
diff --git a/src/boost/detail/shared_count.hpp b/src/boost/detail/shared_count.hpp
deleted file mode 100644
index 23e78413f7..0000000000
--- a/src/boost/detail/shared_count.hpp
+++ /dev/null
@@ -1,555 +0,0 @@
-#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 <boost/config.hpp>
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-//#include <boost/detail/lightweight_mutex.hpp>
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
-#include <memory>           // std::auto_ptr, std::allocator
-#include <functional>       // std::less
-#include <exception>        // std::exception
-#include <new>              // std::bad_alloc
-#include <typeinfo>         // std::type_info in get_deleter
-#include <cstddef>          // std::size_t
-
-#ifdef __BORLANDC__
-# pragma warn -8026     // Functions with excep. spec. are not expanded inline
-# 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<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
-{
-    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
-{
-    boost::sp_array_constructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
-{
-    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
-{
-    boost::sp_array_destructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-#endif
-
-//
-// Borland's Codeguard trips up over the -Vx- option here:
-//
-#ifdef __CODEGUARD__
-# pragma option push -Vx-
-#endif
-
-template<class P, class D> class sp_counted_base_impl: public sp_counted_base
-{
-private:
-
-    P ptr; // copy constructor must not throw
-    D del; // copy constructor must not throw
-
-    sp_counted_base_impl(sp_counted_base_impl const &);
-    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
-
-    typedef sp_counted_base_impl<P, D> this_type;
-
-public:
-
-    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
-
-    sp_counted_base_impl(P p, D d): ptr(p), del(d)
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_constructor_hook(this, p, d, 0);
-#endif
-    }
-
-    virtual void dispose() // nothrow
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_destructor_hook(this, ptr, del, 0);
-#endif
-        del(ptr);
-    }
-
-    virtual void * get_deleter(std::type_info const & ti)
-    {
-        return ti == typeid(D)? &del: 0;
-    }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
-    }
-
-    void operator delete(void * p)
-    {
-        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete(void * p)
-    {
-        quick_allocator<this_type>::dealloc(p);
-    }
-
-#endif
-};
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-int const shared_count_id = 0x2C35F101;
-int const   weak_count_id = 0x298C38A4;
-
-#endif
-
-class weak_count;
-
-class shared_count
-{
-private:
-
-    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<class P, class D> shared_count(P p, D d): pi_(0)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = new sp_counted_base_impl<P, D>(p, d);
-        }
-        catch(...)
-        {
-            d(p); // delete p
-            throw;
-        }
-
-#else
-
-        pi_ = new sp_counted_base_impl<P, D>(p, d);
-
-        if(pi_ == 0)
-        {
-            d(p); // delete p
-            boost::throw_exception(std::bad_alloc());
-        }
-
-#endif
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    // auto_ptr<Y> is special cased to provide the strong guarantee
-
-    template<class Y>
-    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        r.release();
-    }
-
-#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<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-
-    void * get_deleter(std::type_info const & ti) const
-    {
-        return pi_? pi_->get_deleter(ti): 0;
-    }
-};
-
-#ifdef __CODEGUARD__
-# pragma option pop
-#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<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-};
-
-inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-{
-    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/src/boost/detail/workaround.hpp b/src/boost/detail/workaround.hpp
deleted file mode 100644
index 0d5a2b2bcb..0000000000
--- a/src/boost/detail/workaround.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright David Abrahams 2002. 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.
-#ifndef WORKAROUND_DWA2002126_HPP
-# define WORKAROUND_DWA2002126_HPP
-
-// Compiler/library version workaround macro
-//
-// Usage:
-//
-//     #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
-//        ... // workaround code here
-//     #endif
-//
-// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
-// first argument must be undefined or expand to a numeric
-// value. The above expands to:
-//
-//     (BOOST_MSVC) != 0 && (BOOST_MSVC) <= 1200
-//
-// When used for workarounds that apply to the latest known version 
-// and all earlier versions of a compiler, the following convention 
-// should be observed:
-//
-//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
-//
-// The version number in this case corresponds to the last version in
-// which the workaround was known to have been required. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
-// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
-// the workaround for any version of the compiler. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
-// error will be issued if the compiler version exceeds the argument
-// to BOOST_TESTED_AT().  This can be used to locate workarounds which
-// may be obsoleted by newer versions.
-
-# ifndef BOOST_STRICT_CONFIG
-
-#  define BOOST_WORKAROUND(symbol, test)                \
-        ((symbol != 0) && (1 % (( (symbol test) ) + 1)))
-//                              ^ ^           ^ ^
-// The extra level of parenthesis nesting above, along with the
-// BOOST_OPEN_PAREN indirection below, is required to satisfy the
-// broken preprocessor in MWCW 8.3 and earlier.
-//
-// The basic mechanism works as follows:
-//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
-//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
-//
-// The complication with % is for cooperation with BOOST_TESTED_AT().
-// When "test" is BOOST_TESTED_AT(x) and
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
-//
-//      symbol test              =>   if (symbol <= x) then 1 else -1
-//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
-//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
-//
-
-#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
-#   define BOOST_OPEN_PAREN (
-#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
-#  else
-#   define BOOST_TESTED_AT(value) != ((value)-(value))
-#  endif
-
-# else
-
-#  define BOOST_WORKAROUND(symbol, test) 0
-
-# endif 
-
-#endif // WORKAROUND_DWA2002126_HPP
diff --git a/src/boost/enable_shared_from_this.hpp b/src/boost/enable_shared_from_this.hpp
deleted file mode 100644
index 1d52e72c20..0000000000
--- a/src/boost/enable_shared_from_this.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#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 <boost/weak_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/assert.hpp>
-//#include <boost/config.hpp>
-
-namespace boost
-{
-
-template<class T> class enable_shared_from_this
-{
-protected:
-
-    enable_shared_from_this()
-    {
-    }
-
-    enable_shared_from_this(enable_shared_from_this const &)
-    {
-    }
-
-    enable_shared_from_this & operator=(enable_shared_from_this const &)
-    {
-        return *this;
-    }
-
-    ~enable_shared_from_this()
-    {
-    }
-
-public:
-
-    shared_ptr<T> shared_from_this()
-    {
-        shared_ptr<T> p(_internal_weak_this);
-        BOOST_ASSERT(p.get() == this);
-        return p;
-    }
-
-    shared_ptr<T const> shared_from_this() const
-    {
-        shared_ptr<T const> p(_internal_weak_this);
-        BOOST_ASSERT(p.get() == this);
-        return p;
-    }
-
-    typedef T _internal_element_type; // for bcc 5.5.1
-    weak_ptr<_internal_element_type> _internal_weak_this;
-};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
diff --git a/src/boost/shared_ptr.hpp b/src/boost/shared_ptr.hpp
deleted file mode 100644
index 1702ad2688..0000000000
--- a/src/boost/shared_ptr.hpp
+++ /dev/null
@@ -1,474 +0,0 @@
-#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, 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.
-//
-//  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 <boost/detail/workaround.hpp>
-
-#include <memory>               // for std::auto_ptr
-#include <algorithm>            // for std::swap
-#include <functional>           // for std::less
-#include <typeinfo>             // for std::bad_cast
-#include <iosfwd>               // for std::basic_ostream
-
-#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<class T> class weak_ptr;
-template<class T> class enable_shared_from_this;
-
-namespace detail
-{
-
-struct static_cast_tag {};
-struct const_cast_tag {};
-struct dynamic_cast_tag {};
-struct polymorphic_cast_tag {};
-
-template<class 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;
-};
-
-template<> struct shared_ptr_traits<void volatile>
-{
-    typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void const volatile>
-{
-    typedef void reference;
-};
-
-#endif
-
-// enable_shared_from_this support
-
-template<class T, class Y> void sp_enable_shared_from_this(boost::enable_shared_from_this<T> * pe, Y * px, shared_count const & pn)
-{
-    if(pe != 0) pe->_internal_weak_this._internal_assign(px, pn);
-}
-
-inline void sp_enable_shared_from_this(void const volatile *, void const volatile *, shared_count const &)
-{
-}
-
-} // 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<class T> class shared_ptr
-{
-private:
-
-    // Borland 5.5.1 specific workaround
-    typedef shared_ptr<T> this_type;
-
-public:
-
-    typedef T element_type;
-    typedef T value_type;
-    typedef T * pointer;
-    typedef typename detail::shared_ptr_traits<T>::reference reference;
-
-    shared_ptr(): px(0), pn() // never throws in 1.30+
-    {
-    }
-
-    template<class Y>
-    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
-    {
-        detail::sp_enable_shared_from_this(p, p, pn);
-    }
-
-    //
-    // Requirements: D's copy constructor must not throw
-    //
-    // shared_ptr will release p by calling d(p)
-    //
-
-    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
-    {
-        detail::sp_enable_shared_from_this(p, p, pn);
-    }
-
-//  generated copy constructor, assignment, destructor are fine...
-
-//  except that Borland C++ has a bug, and g++ with -Wsynth warns
-#if defined(__BORLANDC__) || defined(__GNUC__)
-
-    shared_ptr & operator=(shared_ptr const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn; // shared_count::op= doesn't throw
-        return *this;
-    }
-
-#endif
-
-    template<class Y>
-    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
-    {
-        // it is now safe to copy r.px, as pn(r.pn) did not throw
-        px = r.px;
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0) // need to allocate new counter -- the cast failed
-        {
-            pn = detail::shared_count();
-        }
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0)
-        {
-            boost::throw_exception(std::bad_cast());
-        }
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    template<class Y>
-    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
-    {
-        Y * tmp = r.get();
-        pn = detail::shared_count(r);
-        detail::sp_enable_shared_from_this(tmp, tmp, pn);
-    }
-
-#endif
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
-
-    template<class 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<class Y>
-    shared_ptr & operator=(std::auto_ptr<Y> & r)
-    {
-        this_type(r).swap(*this);
-        return *this;
-    }
-
-#endif
-
-    void reset() // never throws in 1.30+
-    {
-        this_type().swap(*this);
-    }
-
-    template<class Y> void reset(Y * p) // Y must be complete
-    {
-        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
-        this_type(p).swap(*this);
-    }
-
-    template<class Y, class D> void reset(Y * p, D d)
-    {
-        this_type(p, d).swap(*this);
-    }
-
-    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"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
-    operator bool () const
-    {
-        return px != 0;
-    }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-    typedef T * (this_type::*unspecified_bool_type)() const;
-    
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::get;
-    }
-
-#else 
-
-    typedef T * this_type::*unspecified_bool_type;
-
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::px;
-    }
-
-#endif
-
-    // operator! is redundant, but some compilers need it
-
-    bool operator! () const // never throws
-    {
-        return px == 0;
-    }
-
-    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);
-    }
-
-    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
-    {
-        return pn < rhs.pn;
-    }
-
-    void * _internal_get_deleter(std::type_info const & ti) const
-    {
-        return pn.get_deleter(ti);
-    }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#if 0
-
-private:
-
-    template<class Y> friend class shared_ptr;
-    template<class Y> friend class weak_ptr;
-
-
-#endif
-
-    T * px;                     // contained pointer
-    detail::shared_count pn;    // reference counter
-
-};  // shared_ptr
-
-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();
-}
-
-#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
-
-// Resolve the ambiguity between our op!= and the one in rel_ops
-
-template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
-{
-    return a.get() != b.get();
-}
-
-#endif
-
-template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
-    return a._internal_less(b);
-}
-
-template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
-    a.swap(b);
-}
-
-template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::const_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::dynamic_cast_tag());
-}
-
-// shared_*_cast names are deprecated. Use *_pointer_cast instead.
-
-template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::dynamic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr<T>(r, detail::polymorphic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
-{
-    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
-    return shared_static_cast<T>(r);
-}
-
-// 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();
-}
-
-// operator<<
-
-#if defined(__GNUC__) &&  (__GNUC__ < 3)
-
-template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
-{
-    os << p.get();
-    return os;
-}
-
-#else
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-# else
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-# endif 
-{
-    os << p.get();
-    return os;
-}
-
-#endif
-
-// get_deleter (experimental)
-
-#if (defined(__GNUC__) &&  (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 also doesn't accept it
-
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
-{
-    void const * q = p._internal_get_deleter(typeid(D));
-    return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
-{
-    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
-}
-
-#endif
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
-#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
-#endif  // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
diff --git a/src/boost/weak_ptr.hpp b/src/boost/weak_ptr.hpp
deleted file mode 100644
index 3d3b3eb79d..0000000000
--- a/src/boost/weak_ptr.hpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#ifndef BOOST_WEAK_PTR_HPP_INCLUDED
-#define BOOST_WEAK_PTR_HPP_INCLUDED
-
-//
-//  weak_ptr.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.
-//
-//  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<class 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() // never throws in 1.30+
-    {
-    }
-
-//  generated copy constructor, assignment, destructor are fine
-
-
-//
-//  The "obvious" converting constructor implementation:
-//
-//  template<class Y>
-//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-//  {
-//  }
-//
-//  has a serious problem.
-//
-//  r.px may already have been invalidated. The px(r.px)
-//  conversion may require access to *r.px (virtual inheritance).
-//
-//  It is not possible to avoid spurious access violations since
-//  in multithreaded programs r.px may be invalidated at any point.
-//
-
-    template<class Y>
-    weak_ptr(weak_ptr<Y> const & r): pn(r.pn) // never throws
-    {
-        px = r.lock().get();
-    }
-
-    template<class Y>
-    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-    {
-    }
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
-
-    template<class Y>
-    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
-    {
-        px = r.lock().get();
-        pn = r.pn;
-        return *this;
-    }
-
-    template<class Y>
-    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn;
-        return *this;
-    }
-
-#endif
-
-    shared_ptr<T> lock() const // never throws
-    {
-#if defined(BOOST_HAS_THREADS)
-
-        // optimization: avoid throw overhead
-        if(expired())
-        {
-            return shared_ptr<element_type>();
-        }
-
-        try
-        {
-            return shared_ptr<element_type>(*this);
-        }
-        catch(bad_weak_ptr const &)
-        {
-            // Q: how can we get here?
-            // A: another thread may have invalidated r after the use_count test above.
-            return shared_ptr<element_type>();
-        }
-
-#else
-
-        // optimization: avoid try/catch overhead when single threaded
-        return expired()? shared_ptr<element_type>(): shared_ptr<element_type>(*this);
-
-#endif
-    }
-
-    long use_count() const // never throws
-    {
-        return pn.use_count();
-    }
-
-    bool expired() const // never throws
-    {
-        return pn.use_count() == 0;
-    }
-
-    void reset() // never throws in 1.30+
-    {
-        this_type().swap(*this);
-    }
-
-    void swap(this_type & other) // never throws
-    {
-        std::swap(px, other.px);
-        pn.swap(other.pn);
-    }
-
-    void _internal_assign(T * px2, detail::shared_count const & pn2)
-    {
-        px = px2;
-        pn = pn2;
-    }
-
-    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
-    {
-        return pn < rhs.pn;
-    }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#if 0
-
-private:
-
-    template<class Y> friend class weak_ptr;
-    template<class 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._internal_less(b);
-}
-
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
-{
-    a.swap(b);
-}
-
-// deprecated, provided for backward compatibility
-template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r)
-{
-    return r.lock();
-}
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
-#endif  // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED