Boost-Commit mailing page: [Boost-commit] svn:boost r51531 - in branches/release: boost boost/detail boost/smart_ptr boost/smart_ptr/detail libs/smart

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r51531 - in branches/release: boost boost/detail boost/smart_ptr boost/smart_ptr/detail libs/smart_ptr/test
From: pdimov_at_[hidden]
Date: 2009-03-02 11:22:22

Next message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r51532 - branches/release/boost/bind"
Previous message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r51530 - in branches/release/boost: . bind"

Author: pdimov
Date: 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
New Revision: 51531
URL: http://svn.boost.org/trac/boost/changeset/51531

Log:
Merge [51509], [51519] to release. Closes #2239.
Added:
   branches/release/boost/smart_ptr/
      - copied from r51509, /trunk/boost/smart_ptr/
   branches/release/boost/smart_ptr/bad_weak_ptr.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/bad_weak_ptr.hpp
   branches/release/boost/smart_ptr/detail/
      - copied from r51509, /trunk/boost/smart_ptr/detail/
   branches/release/boost/smart_ptr/detail/atomic_count.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_gcc.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_gcc.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_pthreads.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_pthreads.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_solaris.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_solaris.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_sync.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_sync.hpp
   branches/release/boost/smart_ptr/detail/atomic_count_win32.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/atomic_count_win32.hpp
   branches/release/boost/smart_ptr/detail/lightweight_mutex.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/lightweight_mutex.hpp
   branches/release/boost/smart_ptr/detail/lwm_nop.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/lwm_nop.hpp
   branches/release/boost/smart_ptr/detail/lwm_pthreads.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/lwm_pthreads.hpp
   branches/release/boost/smart_ptr/detail/lwm_win32_cs.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/lwm_win32_cs.hpp
   branches/release/boost/smart_ptr/detail/quick_allocator.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/quick_allocator.hpp
   branches/release/boost/smart_ptr/detail/shared_array_nmt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/shared_array_nmt.hpp
   branches/release/boost/smart_ptr/detail/shared_count.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/shared_count.hpp
   branches/release/boost/smart_ptr/detail/shared_ptr_nmt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/shared_ptr_nmt.hpp
   branches/release/boost/smart_ptr/detail/sp_convertible.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_convertible.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_nt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_nt.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_pt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_pt.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_spin.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_spin.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_sync.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_sync.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_base_w32.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_base_w32.hpp
   branches/release/boost/smart_ptr/detail/sp_counted_impl.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/sp_counted_impl.hpp
   branches/release/boost/smart_ptr/detail/spinlock.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock.hpp
   branches/release/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
   branches/release/boost/smart_ptr/detail/spinlock_nt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_nt.hpp
   branches/release/boost/smart_ptr/detail/spinlock_pool.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_pool.hpp
   branches/release/boost/smart_ptr/detail/spinlock_pt.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_pt.hpp
   branches/release/boost/smart_ptr/detail/spinlock_sync.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_sync.hpp
   branches/release/boost/smart_ptr/detail/spinlock_w32.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/spinlock_w32.hpp
   branches/release/boost/smart_ptr/detail/yield_k.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/detail/yield_k.hpp
   branches/release/boost/smart_ptr/enable_shared_from_this.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/enable_shared_from_this.hpp
   branches/release/boost/smart_ptr/intrusive_ptr.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/intrusive_ptr.hpp
   branches/release/boost/smart_ptr/make_shared.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/make_shared.hpp
   branches/release/boost/smart_ptr/scoped_array.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/scoped_array.hpp
   branches/release/boost/smart_ptr/scoped_ptr.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/scoped_ptr.hpp
   branches/release/boost/smart_ptr/shared_array.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/shared_array.hpp
   branches/release/boost/smart_ptr/shared_ptr.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/shared_ptr.hpp
   branches/release/boost/smart_ptr/weak_ptr.hpp
      - copied unchanged from r51509, /trunk/boost/smart_ptr/weak_ptr.hpp
Removed:
   branches/release/boost/detail/atomic_count_gcc.hpp
   branches/release/boost/detail/atomic_count_gcc_x86.hpp
   branches/release/boost/detail/atomic_count_pthreads.hpp
   branches/release/boost/detail/atomic_count_solaris.hpp
   branches/release/boost/detail/atomic_count_sync.hpp
   branches/release/boost/detail/atomic_count_win32.hpp
   branches/release/boost/detail/bad_weak_ptr.hpp
   branches/release/boost/detail/lwm_nop.hpp
   branches/release/boost/detail/lwm_pthreads.hpp
   branches/release/boost/detail/lwm_win32_cs.hpp
   branches/release/boost/detail/shared_array_nmt.hpp
   branches/release/boost/detail/shared_count.hpp
   branches/release/boost/detail/shared_ptr_nmt.hpp
   branches/release/boost/detail/sp_convertible.hpp
   branches/release/boost/detail/sp_counted_base.hpp
   branches/release/boost/detail/sp_counted_base_acc_ia64.hpp
   branches/release/boost/detail/sp_counted_base_cw_ppc.hpp
   branches/release/boost/detail/sp_counted_base_cw_x86.hpp
   branches/release/boost/detail/sp_counted_base_gcc_ia64.hpp
   branches/release/boost/detail/sp_counted_base_gcc_ppc.hpp
   branches/release/boost/detail/sp_counted_base_gcc_sparc.hpp
   branches/release/boost/detail/sp_counted_base_gcc_x86.hpp
   branches/release/boost/detail/sp_counted_base_nt.hpp
   branches/release/boost/detail/sp_counted_base_pt.hpp
   branches/release/boost/detail/sp_counted_base_solaris.hpp
   branches/release/boost/detail/sp_counted_base_spin.hpp
   branches/release/boost/detail/sp_counted_base_sync.hpp
   branches/release/boost/detail/sp_counted_base_w32.hpp
   branches/release/boost/detail/sp_counted_impl.hpp
   branches/release/boost/detail/spinlock.hpp
   branches/release/boost/detail/spinlock_gcc_arm.hpp
   branches/release/boost/detail/spinlock_nt.hpp
   branches/release/boost/detail/spinlock_pool.hpp
   branches/release/boost/detail/spinlock_pt.hpp
   branches/release/boost/detail/spinlock_sync.hpp
   branches/release/boost/detail/spinlock_w32.hpp
   branches/release/boost/detail/yield_k.hpp
Text files modified:
   branches/release/boost/detail/atomic_count.hpp | 106 -----
   branches/release/boost/detail/lightweight_mutex.hpp | 28 -
   branches/release/boost/detail/quick_allocator.hpp | 183 ---------
   branches/release/boost/enable_shared_from_this.hpp | 63 ---
   branches/release/boost/intrusive_ptr.hpp | 301 ----------------
   branches/release/boost/make_shared.hpp | 418 ----------------------
   branches/release/boost/scoped_array.hpp | 124 ------
   branches/release/boost/scoped_ptr.hpp | 146 -------
   branches/release/boost/shared_array.hpp | 176 ---------
   branches/release/boost/shared_ptr.hpp | 734 ---------------------------------------
   branches/release/boost/weak_ptr.hpp | 172 ---------
   branches/release/libs/smart_ptr/test/spinlock_pool_test.cpp | 2
   branches/release/libs/smart_ptr/test/spinlock_test.cpp | 2
   branches/release/libs/smart_ptr/test/spinlock_try_test.cpp | 2
   branches/release/libs/smart_ptr/test/yield_k_test.cpp | 2
   15 files changed, 33 insertions(+), 2426 deletions(-)

Modified: branches/release/boost/detail/atomic_count.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count.hpp (original)
+++ branches/release/boost/detail/atomic_count.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -12,108 +12,10 @@
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// typedef <implementation-defined> boost::detail::atomic_count;
-//
-// 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...
-//
-
-#include <boost/config.hpp>
-
-#ifndef BOOST_HAS_THREADS
-
-namespace boost
-{
-
-namespace detail
-{
-
-typedef long atomic_count;
-
-}
-
-}
-
-#elif defined(BOOST_AC_USE_PTHREADS)
-# include <boost/detail/atomic_count_pthreads.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-# include <boost/detail/atomic_count_gcc_x86.hpp>
-
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-# include <boost/detail/atomic_count_win32.hpp>
-
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
-# include <boost/detail/atomic_count_sync.hpp>
-
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-# include <boost/detail/atomic_count_gcc.hpp>
-
-#elif defined(BOOST_HAS_PTHREADS)
-
-# define BOOST_AC_USE_PTHREADS
-# include <boost/detail/atomic_count_pthreads.hpp>
-
-#else
-
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-#error Unrecognized threading platform
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt

-#endif
+#include <boost/smart_ptr/detail/atomic_count.hpp>

#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED

Deleted: branches/release/boost/detail/atomic_count_gcc.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_gcc.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,68 +0,0 @@
-#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 <larsbj_at_[hidden]>
-// Copyright 2003-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <bits/atomicity.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if defined(__GLIBCXX__) // g++ 3.4+
-
-using __gnu_cxx::__atomic_add;
-using __gnu_cxx::__exchange_and_add;
-
-#endif
-
-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) - 1;
- }
-
- operator long() const
- {
- return __exchange_and_add(&value_, 0);
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable _Atomic_word value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED

Deleted: branches/release/boost/detail/atomic_count_gcc_x86.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_gcc_x86.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,84 +0,0 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_gcc_x86.hpp
-//
-// atomic_count for g++ on 486+/AMD64
-//
-// Copyright 2007 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ) : value_( static_cast< int >( v ) ) {}
-
- void operator++()
- {
- __asm__
- (
- "lock\n\t"
- "incl %0":
- "+m"( value_ ): // output (%0)
- : // inputs
- "cc" // clobbers
- );
- }
-
- long operator--()
- {
- return atomic_exchange_and_add( &value_, -1 ) - 1;
- }
-
- operator long() const
- {
- return atomic_exchange_and_add( &value_, 0 );
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable int value_;
-
-private:
-
- static int atomic_exchange_and_add( int * pw, int dv )
- {
- // int r = *pw;
- // *pw += dv;
- // return r;
-
- int r;
-
- __asm__ __volatile__
- (
- "lock\n\t"
- "xadd %1, %0":
- "+m"( *pw ), "=r"( r ): // outputs (%0, %1)
- "1"( dv ): // inputs (%2 == %1)
- "memory", "cc" // clobbers
- );
-
- return r;
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED

Deleted: branches/release/boost/detail/atomic_count_pthreads.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_pthreads.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,96 +0,0 @@
-#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.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <pthread.h>
-
-//
-// 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

Deleted: branches/release/boost/detail/atomic_count_solaris.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_solaris.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,59 +0,0 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_solaris.hpp
-// based on: boost/detail/atomic_count_win32.hpp
-//
-// Copyright (c) 2001-2005 Peter Dimov
-// Copyright (c) 2006 Michael van der Westhuizen
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <atomic.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( uint32_t v ): value_( v )
- {
- }
-
- long operator++()
- {
- return atomic_inc_32_nv( &value_ );
- }
-
- long operator--()
- {
- return atomic_dec_32_nv( &value_ );
- }
-
- operator uint32_t() const
- {
- return static_cast<uint32_t const volatile &>( value_ );
- }
-
-private:
-
- atomic_count( atomic_count const & );
- atomic_count & operator=( atomic_count const & );
-
- uint32_t value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED

Deleted: branches/release/boost/detail/atomic_count_sync.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_sync.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,61 +0,0 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_sync.hpp
-//
-// atomic_count for g++ 4.1+
-//
-// http://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html
-//
-// Copyright 2007 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
-# include <ia64intrin.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ) : value_( v ) {}
-
- void operator++()
- {
- __sync_add_and_fetch( &value_, 1 );
- }
-
- long operator--()
- {
- return __sync_add_and_fetch( &value_, -1 );
- }
-
- operator long() const
- {
- return __sync_fetch_and_add( &value_, 0 );
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED

Deleted: branches/release/boost/detail/atomic_count_win32.hpp
==============================================================================
--- branches/release/boost/detail/atomic_count_win32.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,63 +0,0 @@
-#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-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/interlocked.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ): value_( v )
- {
- }
-
- long operator++()
- {
- return BOOST_INTERLOCKED_INCREMENT( &value_ );
- }
-
- long operator--()
- {
- return BOOST_INTERLOCKED_DECREMENT( &value_ );
- }
-
- operator long() const
- {
- return static_cast<long const volatile &>( value_ );
- }
-
-private:
-
- atomic_count( atomic_count const & );
- atomic_count & operator=( atomic_count const & );
-
- long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED

Deleted: branches/release/boost/detail/bad_weak_ptr.hpp
==============================================================================
--- branches/release/boost/detail/bad_weak_ptr.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,59 +0,0 @@
-#ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED
-#define BOOST_BAD_WEAK_PTR_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/bad_weak_ptr.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <exception>
-
-#ifdef __BORLANDC__
-# pragma warn -8026 // Functions with excep. spec. are not expanded inline
-#endif
-
-namespace boost
-{
-
-// The standard library that comes with Borland C++ 5.5.1, 5.6.4
-// 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.
-
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
-# pragma option push -pc
-#endif
-
-class bad_weak_ptr: public std::exception
-{
-public:
-
- virtual char const * what() const throw()
- {
- return "tr1::bad_weak_ptr";
- }
-};
-
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
-# pragma option pop
-#endif
-
-} // namespace boost
-
-#ifdef __BORLANDC__
-# pragma warn .8026 // Functions with excep. spec. are not expanded inline
-#endif
-
-#endif // #ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED

Modified: branches/release/boost/detail/lightweight_mutex.hpp
==============================================================================
--- branches/release/boost/detail/lightweight_mutex.hpp (original)
+++ branches/release/boost/detail/lightweight_mutex.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -12,31 +12,11 @@
//
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
-// typedef <unspecified> boost::detail::lightweight_mutex;
-//
-// boost::detail::lightweight_mutex is a header-only implementation of
-// a subset of the Mutex concept requirements:
-//
-// http://www.boost.org/doc/html/threads/concepts.html#threads.concepts.Mutex
-//
-// It maps to a CRITICAL_SECTION on Windows or a pthread_mutex on POSIX.
-//
-
-#include <boost/config.hpp>

-#if !defined(BOOST_HAS_THREADS)
-# include <boost/detail/lwm_nop.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
-# include <boost/detail/lwm_pthreads.hpp>
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-# include <boost/detail/lwm_win32_cs.hpp>
-#else
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-# error Unrecognized threading platform
-#endif
+#include <boost/smart_ptr/detail/lightweight_mutex.hpp>

#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED

Deleted: branches/release/boost/detail/lwm_nop.hpp
==============================================================================
--- branches/release/boost/detail/lwm_nop.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,37 +0,0 @@
-#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.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class lightweight_mutex
-{
-public:
-
- typedef lightweight_mutex scoped_lock;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED

Deleted: branches/release/boost/detail/lwm_pthreads.hpp
==============================================================================
--- branches/release/boost/detail/lwm_pthreads.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,86 +0,0 @@
-#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.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <pthread.h>
-
-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

Deleted: branches/release/boost/detail/lwm_win32_cs.hpp
==============================================================================
--- branches/release/boost/detail/lwm_win32_cs.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,108 +0,0 @@
-#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
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifdef BOOST_USE_WINDOWS_H
-# include <windows.h>
-#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 *);
-
-#else
-
-typedef ::CRITICAL_SECTION 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

Modified: branches/release/boost/detail/quick_allocator.hpp
==============================================================================
--- branches/release/boost/detail/quick_allocator.hpp (original)
+++ branches/release/boost/detail/quick_allocator.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -13,186 +13,11 @@
// Copyright (c) 2003 David Abrahams
// Copyright (c) 2003 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//

-#include <boost/config.hpp>
-
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-#include <new> // ::operator new, ::operator delete
-#include <cstddef> // std::size_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<unsigned size, unsigned align_> union freeblock
-{
- typedef typename boost::type_with_alignment<align_>::type aligner_type;
- aligner_type aligner;
- char bytes[size];
- freeblock * next;
-};
-
-template<unsigned size, unsigned align_> struct allocator_impl
-{
- typedef freeblock<size, align_> block;
-
- // It may seem odd to use such small pages.
- //
- // However, on a typical Windows implementation that uses
- // the OS allocator, "normal size" pages interact with the
- // "ordinary" operator new, slowing it down dramatically.
- //
- // 512 byte pages are handled by the small object allocator,
- // and don't interfere with ::new.
- //
- // The other alternative is to use much bigger pages (1M.)
- //
- // It is surprisingly easy to hit pathological behavior by
- // varying the page size. g++ 2.96 on Red Hat Linux 7.2,
- // for example, passionately dislikes 496. 512 seems OK.
-
-#if defined(BOOST_QA_PAGE_SIZE)
-
- enum { items_per_page = BOOST_QA_PAGE_SIZE / size };
-
-#else
-
- enum { items_per_page = 512 / size }; // 1048560 / size
-
-#endif
-
-#ifdef BOOST_HAS_THREADS
-
- static lightweight_mutex & mutex()
- {
- static lightweight_mutex m;
- return m;
- }
-
- static lightweight_mutex * mutex_init;
-
-#endif
-
- static block * free;
- static block * page;
- static unsigned last;
-
- static inline void * alloc()
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- if(block * x = free)
- {
- free = x->next;
- return x;
- }
- else
- {
- if(last == items_per_page)
- {
- // "Listen to me carefully: there is no memory leak"
- // -- Scott Meyers, Eff C++ 2nd Ed Item 10
- page = ::new block[items_per_page];
- last = 0;
- }
-
- return &page[last++];
- }
- }
-
- static inline void * alloc(std::size_t n)
- {
- if(n != size) // class-specific new called for a derived object
- {
- return ::operator new(n);
- }
- else
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- if(block * x = free)
- {
- free = x->next;
- return x;
- }
- else
- {
- if(last == items_per_page)
- {
- page = ::new block[items_per_page];
- last = 0;
- }
-
- return &page[last++];
- }
- }
- }
-
- static inline void dealloc(void * pv)
- {
- if(pv != 0) // 18.4.1.1/13
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- block * pb = static_cast<block *>(pv);
- pb->next = free;
- free = pb;
- }
- }
-
- static inline void dealloc(void * pv, std::size_t n)
- {
- if(n != size) // class-specific delete called for a derived object
- {
- ::operator delete(pv);
- }
- else if(pv != 0) // 18.4.1.1/13
- {
-#ifdef BOOST_HAS_THREADS
- lightweight_mutex::scoped_lock lock( mutex() );
-#endif
- block * pb = static_cast<block *>(pv);
- pb->next = free;
- free = pb;
- }
- }
-};
-
-#ifdef BOOST_HAS_THREADS
-
-template<unsigned size, unsigned align_>
- lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex();
-
-#endif
-
-template<unsigned size, unsigned align_>
- freeblock<size, align_> * allocator_impl<size, align_>::free = 0;
-
-template<unsigned size, unsigned align_>
- freeblock<size, align_> * allocator_impl<size, align_>::page = 0;
-
-template<unsigned size, unsigned align_>
- unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
-
-template<class T>
-struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
+#include <boost/smart_ptr/detail/quick_allocator.hpp>

#endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

Deleted: branches/release/boost/detail/shared_array_nmt.hpp
==============================================================================
--- branches/release/boost/detail/shared_array_nmt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,151 +0,0 @@
-#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
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/detail/atomic_count.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <new> // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_array
-{
-private:
-
- typedef detail::atomic_count count_type;
-
-public:
-
- typedef T element_type;
-
- explicit shared_array(T * p = 0): px(p)
- {
-#ifndef BOOST_NO_EXCEPTIONS
-
- try // prevent leak if new throws
- {
- pn = new count_type(1);
- }
- catch(...)
- {
- boost::checked_array_delete(p);
- throw;
- }
-
-#else
-
- pn = new count_type(1);
-
- if(pn == 0)
- {
- boost::checked_array_delete(p);
- boost::throw_exception(std::bad_alloc());
- }
-
-#endif
- }
-
- ~shared_array()
- {
- if(--*pn == 0)
- {
- boost::checked_array_delete(px);
- delete pn;
- }
- }
-
- shared_array(shared_array const & r) : px(r.px) // never throws
- {
- pn = r.pn;
- ++*pn;
- }
-
- shared_array & operator=(shared_array const & r)
- {
- shared_array(r).swap(*this);
- return *this;
- }
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- shared_array(p).swap(*this);
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- T & operator[](std::ptrdiff_t i) const // never throws
- {
- BOOST_ASSERT(px != 0);
- BOOST_ASSERT(i >= 0);
- return px[i];
- }
-
- long use_count() const // never throws
- {
- return *pn;
- }
-
- bool unique() const // never throws
- {
- return *pn == 1;
- }
-
- void swap(shared_array<T> & other) // never throws
- {
- std::swap(px, other.px);
- std::swap(pn, other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- count_type * pn; // ptr to reference counter
-
-}; // shared_array
-
-template<class T, class U> inline bool operator==(shared_array<T> const & a, shared_array const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_array<T> const & a, shared_array const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b)
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED

Deleted: branches/release/boost/detail/shared_count.hpp
==============================================================================
--- branches/release/boost/detail/shared_count.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,430 +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.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifdef __BORLANDC__
-# pragma warn -8027 // Functions containing try are not expanded inline
-#endif
-
-#include <boost/config.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/detail/bad_weak_ptr.hpp>
-#include <boost/detail/sp_counted_base.hpp>
-#include <boost/detail/sp_counted_impl.hpp>
-#include <boost/detail/workaround.hpp>
-// In order to avoid circular dependencies with Boost.TR1
-// we make sure that our include of <memory> doesn't try to
-// pull in the TR1 headers: that's why we use this header
-// rather than including <memory> directly:
-#include <boost/config/no_tr1/memory.hpp> // std::auto_ptr
-#include <functional> // std::less
-#include <new> // std::bad_alloc
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-int const shared_count_id = 0x2C35F101;
-int const weak_count_id = 0x298C38A4;
-
-#endif
-
-struct sp_nothrow_tag {};
-
-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 Y> explicit shared_count( Y * p ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
- {
-#ifndef BOOST_NO_EXCEPTIONS
-
- try
- {
- pi_ = new sp_counted_impl_p<Y>( p );
- }
- catch(...)
- {
- boost::checked_delete( p );
- throw;
- }
-
-#else
-
- pi_ = new sp_counted_impl_p<Y>( p );
-
- if( pi_ == 0 )
- {
- boost::checked_delete( p );
- boost::throw_exception( std::bad_alloc() );
- }
-
-#endif
- }
-
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
- template<class Y, class D> shared_count( Y * p, D d ): pi_(0)
-#else
- template<class P, class D> shared_count( P p, D d ): pi_(0)
-#endif
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
- {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
- typedef Y* P;
-#endif
-#ifndef BOOST_NO_EXCEPTIONS
-
- try
- {
- pi_ = new sp_counted_impl_pd<P, D>(p, d);
- }
- catch(...)
- {
- d(p); // delete p
- throw;
- }
-
-#else
-
- pi_ = new sp_counted_impl_pd<P, D>(p, d);
-
- if(pi_ == 0)
- {
- d(p); // delete p
- boost::throw_exception(std::bad_alloc());
- }
-
-#endif
- }
-
- template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
- {
- typedef sp_counted_impl_pda<P, D, A> impl_type;
- typedef typename A::template rebind< impl_type >::other A2;
-
- A2 a2( a );
-
-#ifndef BOOST_NO_EXCEPTIONS
-
- try
- {
- pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
- new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
- }
- catch(...)
- {
- d( p );
-
- if( pi_ != 0 )
- {
- a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
- }
-
- throw;
- }
-
-#else
-
- pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
-
- if( pi_ != 0 )
- {
- new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
- }
- else
- {
- d( 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_impl_p<Y>( r.get() ) )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
- {
-#ifdef BOOST_NO_EXCEPTIONS
-
- if( pi_ == 0 )
- {
- boost::throw_exception(std::bad_alloc());
- }
-
-#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();
- }
-
-#if defined( BOOST_HAS_RVALUE_REFS )
-
- shared_count(shared_count && r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
- {
- r.pi_ = 0;
- }
-
-#endif
-
- explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
- shared_count( weak_count const & r, sp_nothrow_tag ); // constructs an empty *this when r.use_count() == 0
-
- shared_count & operator= (shared_count const & r) // nothrow
- {
- sp_counted_base * tmp = r.pi_;
-
- if( tmp != pi_ )
- {
- if( tmp != 0 ) tmp->add_ref_copy();
- if( pi_ != 0 ) pi_->release();
- pi_ = tmp;
- }
-
- return *this;
- }
-
- void swap(shared_count & r) // nothrow
- {
- 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;
- }
-
- bool empty() const // nothrow
- {
- return pi_ == 0;
- }
-
- 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( sp_typeinfo const & ti ) const
- {
- return pi_? pi_->get_deleter( ti ): 0;
- }
-};
-
-
-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 != 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 != 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;
- }
-
- bool empty() const // nothrow
- {
- return pi_ == 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() )
- {
- boost::throw_exception( boost::bad_weak_ptr() );
- }
-}
-
-inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- , id_(shared_count_id)
-#endif
-{
- if( pi_ != 0 && !pi_->add_ref_lock() )
- {
- pi_ = 0;
- }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#ifdef __BORLANDC__
-# pragma warn .8027 // Functions containing try are not expanded inline
-#endif
-
-#endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED

Deleted: branches/release/boost/detail/shared_ptr_nmt.hpp
==============================================================================
--- branches/release/boost/detail/shared_ptr_nmt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,182 +0,0 @@
-#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
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/detail/atomic_count.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory> // for std::auto_ptr
-#endif
-
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <new> // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_ptr
-{
-private:
-
- typedef detail::atomic_count count_type;
-
-public:
-
- typedef T element_type;
- typedef T value_type;
-
- explicit shared_ptr(T * p = 0): px(p)
- {
-#ifndef BOOST_NO_EXCEPTIONS
-
- try // prevent leak if new throws
- {
- pn = new count_type(1);
- }
- catch(...)
- {
- boost::checked_delete(p);
- throw;
- }
-
-#else
-
- pn = new count_type(1);
-
- if(pn == 0)
- {
- boost::checked_delete(p);
- boost::throw_exception(std::bad_alloc());
- }
-
-#endif
- }
-
- ~shared_ptr()
- {
- if(--*pn == 0)
- {
- boost::checked_delete(px);
- delete pn;
- }
- }
-
- shared_ptr(shared_ptr const & r): px(r.px) // never throws
- {
- pn = r.pn;
- ++*pn;
- }
-
- shared_ptr & operator=(shared_ptr const & r)
- {
- shared_ptr(r).swap(*this);
- return *this;
- }
-
-#ifndef BOOST_NO_AUTO_PTR
-
- explicit shared_ptr(std::auto_ptr<T> & r)
- {
- pn = new count_type(1); // may throw
- px = r.release(); // fix: moved here to stop leak if new throws
- }
-
- shared_ptr & operator=(std::auto_ptr<T> & r)
- {
- shared_ptr(r).swap(*this);
- return *this;
- }
-
-#endif
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- shared_ptr(p).swap(*this);
- }
-
- T & operator*() const // never throws
- {
- BOOST_ASSERT(px != 0);
- return *px;
- }
-
- T * operator->() const // never throws
- {
- BOOST_ASSERT(px != 0);
- return px;
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- long use_count() const // never throws
- {
- return *pn;
- }
-
- bool unique() const // never throws
- {
- return *pn == 1;
- }
-
- void swap(shared_ptr<T> & other) // never throws
- {
- std::swap(px, other.px);
- std::swap(pn, other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- count_type * pn; // ptr to reference counter
-};
-
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
- a.swap(b);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr<T> const & p)
-{
- return p.get();
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_convertible.hpp
==============================================================================
--- branches/release/boost/detail/sp_convertible.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,76 +0,0 @@
-#ifndef BOOST_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
-#define BOOST_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// detail/sp_convertible.hpp
-//
-// Copyright 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/config.hpp>
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ < 303 )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __BORLANDC__ ) && ( __BORLANDC__ <= 0x610 )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< class Y, class T > struct sp_convertible
-{
- typedef char (&yes) [1];
- typedef char (&no) [2];
-
- static yes f( T* );
- static no f( ... );
-
- enum _vt { value = sizeof( f( (Y*)0 ) ) == sizeof(yes) };
-};
-
-struct sp_empty
-{
-};
-
-template< bool > struct sp_enable_if_convertible_impl;
-
-template<> struct sp_enable_if_convertible_impl<true>
-{
- typedef sp_empty type;
-};
-
-template<> struct sp_enable_if_convertible_impl<false>
-{
-};
-
-template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-#endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,66 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base.hpp
-//
-// Copyright 2005, 2006 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/config.hpp>
-
-#if defined( BOOST_SP_DISABLE_THREADS )
-# include <boost/detail/sp_counted_base_nt.hpp>
-
-#elif defined( BOOST_SP_USE_SPINLOCK )
-# include <boost/detail/sp_counted_base_spin.hpp>
-
-#elif defined( BOOST_SP_USE_PTHREADS )
-# include <boost/detail/sp_counted_base_pt.hpp>
-
-#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
-# include <boost/detail/sp_counted_base_nt.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-# include <boost/detail/sp_counted_base_gcc_x86.hpp>
-
-#elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER )
-# include <boost/detail/sp_counted_base_gcc_ia64.hpp>
-
-#elif defined(__HP_aCC) && defined(__ia64)
-# include <boost/detail/sp_counted_base_acc_ia64.hpp>
-
-#elif defined( __MWERKS__ ) && defined( __POWERPC__ )
-# include <boost/detail/sp_counted_base_cw_ppc.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) )
-# include <boost/detail/sp_counted_base_gcc_ppc.hpp>
-
-#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
-# include <boost/detail/sp_counted_base_sync.hpp>
-
-#elif defined(__GNUC__) && ( defined( __sparcv9 ) || ( defined( __sparcv8 ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 402 ) ) )
-# include <boost/detail/sp_counted_base_gcc_sparc.hpp>
-
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
-# include <boost/detail/sp_counted_base_w32.hpp>
-
-#elif !defined( BOOST_HAS_THREADS )
-# include <boost/detail/sp_counted_base_nt.hpp>
-
-#else
-# include <boost/detail/sp_counted_base_spin.hpp>
-
-#endif
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_acc_ia64.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_acc_ia64.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,150 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED
-
-//
-// detail/sp_counted_base_acc_ia64.hpp - aC++ on HP-UX IA64
-//
-// Copyright 2007 Baruch Zilber
-// Copyright 2007 Boris Gubenko
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <machine/sys/inline.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( int * pw )
-{
- // ++*pw;
-
- _Asm_fetchadd(_FASZ_W, _SEM_REL, pw, +1, _LDHINT_NONE);
-}
-
-inline int atomic_decrement( int * pw )
-{
- // return --*pw;
-
- int r = static_cast<int>(_Asm_fetchadd(_FASZ_W, _SEM_REL, pw, -1, _LDHINT_NONE));
- if (1 == r)
- {
- _Asm_mf();
- }
-
- return r - 1;
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- // if( *pw != 0 ) ++*pw;
- // return *pw;
-
- int v = *pw;
-
- for (;;)
- {
- if (0 == v)
- {
- return 0;
- }
-
- _Asm_mov_to_ar(_AREG_CCV,
- v,
- (_UP_CALL_FENCE | _UP_SYS_FENCE | _DOWN_CALL_FENCE | _DOWN_SYS_FENCE));
- int r = static_cast<int>(_Asm_cmpxchg(_SZ_W, _SEM_ACQ, pw, v + 1, _LDHINT_NONE));
- if (r == v)
- {
- return r + 1;
- }
-
- v = r;
- }
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<int const volatile &>( use_count_ ); // TODO use ld.acq here
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_ACC_IA64_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_cw_ppc.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_cw_ppc.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,170 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_cw_ppc.hpp - CodeWarrior on PowerPC
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( register long * pw )
-{
- register int a;
-
- asm
- {
-loop:
-
- lwarx a, 0, pw
- addi a, a, 1
- stwcx. a, 0, pw
- bne- loop
- }
-}
-
-inline long atomic_decrement( register long * pw )
-{
- register int a;
-
- asm
- {
- sync
-
-loop:
-
- lwarx a, 0, pw
- addi a, a, -1
- stwcx. a, 0, pw
- bne- loop
-
- isync
- }
-
- return a;
-}
-
-inline long atomic_conditional_increment( register long * pw )
-{
- register int a;
-
- asm
- {
-loop:
-
- lwarx a, 0, pw
- cmpwi a, 0
- beq store
-
- addi a, a, 1
-
-store:
-
- stwcx. a, 0, pw
- bne- loop
- }
-
- return a;
-}
-
-class sp_counted_base
-{
-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)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<long const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_cw_x86.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_cw_x86.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,158 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_cw_x86.hpp - CodeWarrion on 486+
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-// Copyright 2005 Rene Rivera
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int atomic_exchange_and_add( int * pw, int dv )
-{
- // int r = *pw;
- // *pw += dv;
- // return r;
-
- asm
- {
- mov esi, [pw]
- mov eax, dv
- lock xadd dword ptr [esi], eax
- }
-}
-
-inline void atomic_increment( int * pw )
-{
- //atomic_exchange_and_add( pw, 1 );
-
- asm
- {
- mov esi, [pw]
- lock inc dword ptr [esi]
- }
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- // int rv = *pw;
- // if( rv != 0 ) ++*pw;
- // return rv;
-
- asm
- {
- mov esi, [pw]
- mov eax, dword ptr [esi]
- L0:
- test eax, eax
- je L1
- mov ebx, eax
- inc ebx
- lock cmpxchg dword ptr [esi], ebx
- jne L0
- L1:
- }
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<int const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_gcc_ia64.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_gcc_ia64.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,157 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
-
-//
-// detail/sp_counted_base_gcc_ia64.hpp - g++ on IA64
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2006 Peter Dimov
-// Copyright 2005 Ben Hutchings
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( int * pw )
-{
- // ++*pw;
-
- int tmp;
-
- // No barrier is required here but fetchadd always has an acquire or
- // release barrier associated with it. We choose release as it should be
- // cheaper.
- __asm__ ("fetchadd4.rel %0=%1,1" :
- "=r"(tmp), "=m"(*pw) :
- "m"( *pw ));
-}
-
-inline int atomic_decrement( int * pw )
-{
- // return --*pw;
-
- int rv;
-
- __asm__ (" fetchadd4.rel %0=%1,-1 ;; \n"
- " cmp.eq p7,p0=1,%0 ;; \n"
- "(p7) ld4.acq %0=%1 " :
- "=&r"(rv), "=m"(*pw) :
- "m"( *pw ) :
- "p7");
-
- return rv;
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- // if( *pw != 0 ) ++*pw;
- // return *pw;
-
- int rv, tmp, tmp2;
-
- __asm__ ("0: ld4 %0=%3 ;; \n"
- " cmp.eq p7,p0=0,%0 ;; \n"
- "(p7) br.cond.spnt 1f \n"
- " mov ar.ccv=%0 \n"
- " add %1=1,%0 ;; \n"
- " cmpxchg4.acq %2=%3,%1,ar.ccv ;; \n"
- " cmp.ne p7,p0=%0,%2 ;; \n"
- "(p7) br.cond.spnt 0b \n"
- " mov %0=%1 ;; \n"
- "1:" :
- "=&r"(rv), "=&r"(tmp), "=&r"(tmp2), "=m"(*pw) :
- "m"( *pw ) :
- "ar.ccv", "p7");
-
- return rv;
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<int const volatile &>( use_count_ ); // TODO use ld.acq here
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_gcc_ppc.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_gcc_ppc.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,181 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_gcc_ppc.hpp - g++ on PowerPC
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( int * pw )
-{
- // ++*pw;
-
- int tmp;
-
- __asm__
- (
- "0:\n\t"
- "lwarx %1, 0, %2\n\t"
- "addi %1, %1, 1\n\t"
- "stwcx. %1, 0, %2\n\t"
- "bne- 0b":
-
- "=m"( *pw ), "=&b"( tmp ):
- "r"( pw ), "m"( *pw ):
- "cc"
- );
-}
-
-inline int atomic_decrement( int * pw )
-{
- // return --*pw;
-
- int rv;
-
- __asm__ __volatile__
- (
- "sync\n\t"
- "0:\n\t"
- "lwarx %1, 0, %2\n\t"
- "addi %1, %1, -1\n\t"
- "stwcx. %1, 0, %2\n\t"
- "bne- 0b\n\t"
- "isync":
-
- "=m"( *pw ), "=&b"( rv ):
- "r"( pw ), "m"( *pw ):
- "memory", "cc"
- );
-
- return rv;
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- // if( *pw != 0 ) ++*pw;
- // return *pw;
-
- int rv;
-
- __asm__
- (
- "0:\n\t"
- "lwarx %1, 0, %2\n\t"
- "cmpwi %1, 0\n\t"
- "beq 1f\n\t"
- "addi %1, %1, 1\n\t"
- "1:\n\t"
- "stwcx. %1, 0, %2\n\t"
- "bne- 0b":
-
- "=m"( *pw ), "=&b"( rv ):
- "r"( pw ), "m"( *pw ):
- "cc"
- );
-
- return rv;
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<int const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_gcc_sparc.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_gcc_sparc.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,166 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// detail/sp_counted_base_gcc_sparc.hpp - g++ on Sparc V8+
-//
-// Copyright (c) 2006 Piotr Wyderski
-// Copyright (c) 2006 Tomas Puverle
-// Copyright (c) 2006 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-//
-// Thanks to Michael van der Westhuizen
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <inttypes.h> // int32_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int32_t compare_and_swap( int32_t * dest_, int32_t compare_, int32_t swap_ )
-{
- __asm__ __volatile__( "cas %0, %2, %1"
- : "+m" (*dest_), "+r" (swap_)
- : "r" (compare_)
- : "memory" );
-
- return swap_;
-}
-
-inline int32_t atomic_fetch_and_add( int32_t * pw, int32_t dv )
-{
- // long r = *pw;
- // *pw += dv;
- // return r;
-
- for( ;; )
- {
- int32_t r = *pw;
-
- if( __builtin_expect((compare_and_swap(pw, r, r + dv) == r), 1) )
- {
- return r;
- }
- }
-}
-
-inline void atomic_increment( int32_t * pw )
-{
- atomic_fetch_and_add( pw, 1 );
-}
-
-inline int32_t atomic_decrement( int32_t * pw )
-{
- return atomic_fetch_and_add( pw, -1 );
-}
-
-inline int32_t atomic_conditional_increment( int32_t * pw )
-{
- // long r = *pw;
- // if( r != 0 ) ++*pw;
- // return r;
-
- for( ;; )
- {
- int32_t r = *pw;
-
- if( r == 0 )
- {
- return r;
- }
-
- if( __builtin_expect( ( compare_and_swap( pw, r, r + 1 ) == r ), 1 ) )
- {
- return r;
- }
- }
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int32_t use_count_; // #shared
- int32_t weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 1 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 1 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return const_cast< int32_t const volatile & >( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_SPARC_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_gcc_x86.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_gcc_x86.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,173 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_gcc_x86.hpp - g++ on 486+ or AMD64
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int atomic_exchange_and_add( int * pw, int dv )
-{
- // int r = *pw;
- // *pw += dv;
- // return r;
-
- int r;
-
- __asm__ __volatile__
- (
- "lock\n\t"
- "xadd %1, %0":
- "=m"( *pw ), "=r"( r ): // outputs (%0, %1)
- "m"( *pw ), "1"( dv ): // inputs (%2, %3 == %1)
- "memory", "cc" // clobbers
- );
-
- return r;
-}
-
-inline void atomic_increment( int * pw )
-{
- //atomic_exchange_and_add( pw, 1 );
-
- __asm__
- (
- "lock\n\t"
- "incl %0":
- "=m"( *pw ): // output (%0)
- "m"( *pw ): // input (%1)
- "cc" // clobbers
- );
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- // int rv = *pw;
- // if( rv != 0 ) ++*pw;
- // return rv;
-
- int rv, tmp;
-
- __asm__
- (
- "movl %0, %%eax\n\t"
- "0:\n\t"
- "test %%eax, %%eax\n\t"
- "je 1f\n\t"
- "movl %%eax, %2\n\t"
- "incl %2\n\t"
- "lock\n\t"
- "cmpxchgl %2, %0\n\t"
- "jne 0b\n\t"
- "1:":
- "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ): // outputs (%0, %1, %2)
- "m"( *pw ): // input (%3)
- "cc" // clobbers
- );
-
- return rv;
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<int const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_nt.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_nt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,107 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_nt.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-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)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- ++use_count_;
- }
-
- bool add_ref_lock() // true on success
- {
- if( use_count_ == 0 ) return false;
- ++use_count_;
- return true;
- }
-
- void release() // nothrow
- {
- if( --use_count_ == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- ++weak_count_;
- }
-
- void weak_release() // nothrow
- {
- if( --weak_count_ == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return use_count_;
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_pt.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_pt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,135 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_pt.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <pthread.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-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)
-
- mutable pthread_mutex_t m_;
-
-public:
-
- sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
- {
-// 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
- }
-
- virtual ~sp_counted_base() // nothrow
- {
- pthread_mutex_destroy( &m_ );
- }
-
- // dispose() is called when use_count_ drops to zero, to release
- // the resources managed by *this.
-
- virtual void dispose() = 0; // nothrow
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- pthread_mutex_lock( &m_ );
- ++use_count_;
- pthread_mutex_unlock( &m_ );
- }
-
- bool add_ref_lock() // true on success
- {
- pthread_mutex_lock( &m_ );
- bool r = use_count_ == 0? false: ( ++use_count_, true );
- pthread_mutex_unlock( &m_ );
- return r;
- }
-
- void release() // nothrow
- {
- pthread_mutex_lock( &m_ );
- long new_use_count = --use_count_;
- pthread_mutex_unlock( &m_ );
-
- if( new_use_count == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- pthread_mutex_lock( &m_ );
- ++weak_count_;
- pthread_mutex_unlock( &m_ );
- }
-
- void weak_release() // nothrow
- {
- pthread_mutex_lock( &m_ );
- long new_weak_count = --weak_count_;
- pthread_mutex_unlock( &m_ );
-
- if( new_weak_count == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- pthread_mutex_lock( &m_ );
- long r = use_count_;
- pthread_mutex_unlock( &m_ );
-
- return r;
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_solaris.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_solaris.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,113 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED
-
-//
-// detail/sp_counted_base_solaris.hpp
-// based on: detail/sp_counted_base_w32.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-// Copyright 2006 Michael van der Westhuizen
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <atomic.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- uint32_t use_count_; // #shared
- uint32_t weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_inc_32( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- for( ;; )
- {
- uint32_t tmp = static_cast< uint32_t const volatile& >( use_count_ );
- if( tmp == 0 ) return false;
- if( atomic_cas_32( &use_count_, tmp, tmp + 1 ) == tmp ) return true;
- }
- }
-
- void release() // nothrow
- {
- if( atomic_dec_32_nv( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_inc_32( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_dec_32_nv( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<long const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_SOLARIS_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_spin.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_spin.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,131 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_spin.hpp - spinlock pool atomic emulation
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <boost/detail/spinlock_pool.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int atomic_exchange_and_add( int * pw, int dv )
-{
- spinlock_pool<1>::scoped_lock lock( pw );
-
- int r = *pw;
- *pw += dv;
- return r;
-}
-
-inline void atomic_increment( int * pw )
-{
- spinlock_pool<1>::scoped_lock lock( pw );
- ++*pw;
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
- spinlock_pool<1>::scoped_lock lock( pw );
-
- int rv = *pw;
- if( rv != 0 ) ++*pw;
- return rv;
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- int use_count_; // #shared
- int weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- spinlock_pool<1>::scoped_lock lock( &use_count_ );
- return use_count_;
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_sync.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_sync.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,155 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// detail/sp_counted_base_sync.hpp - g++ 4.1+ __sync intrinsics
-//
-// Copyright (c) 2007 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <limits.h>
-
-#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
-# include <ia64intrin.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if INT_MAX >= 2147483647
-
-typedef int sp_int32_t;
-
-#else
-
-typedef long sp_int32_t;
-
-#endif
-
-inline void atomic_increment( sp_int32_t * pw )
-{
- __sync_fetch_and_add( pw, 1 );
-}
-
-inline sp_int32_t atomic_decrement( sp_int32_t * pw )
-{
- return __sync_fetch_and_add( pw, -1 );
-}
-
-inline sp_int32_t atomic_conditional_increment( sp_int32_t * pw )
-{
- // long r = *pw;
- // if( r != 0 ) ++*pw;
- // return r;
-
- sp_int32_t r = *pw;
-
- for( ;; )
- {
- if( r == 0 )
- {
- return r;
- }
-
- sp_int32_t r2 = __sync_val_compare_and_swap( pw, r, r + 1 );
-
- if( r2 == r )
- {
- return r;
- }
- else
- {
- r = r2;
- }
- }
-}
-
-class sp_counted_base
-{
-private:
-
- sp_counted_base( sp_counted_base const & );
- sp_counted_base & operator= ( sp_counted_base const & );
-
- sp_int32_t use_count_; // #shared
- sp_int32_t weak_count_; // #weak + (#shared != 0)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- atomic_increment( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- return atomic_conditional_increment( &use_count_ ) != 0;
- }
-
- void release() // nothrow
- {
- if( atomic_decrement( &use_count_ ) == 1 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- atomic_increment( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( atomic_decrement( &weak_count_ ) == 1 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return const_cast< sp_int32_t const volatile & >( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_base_w32.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_base_w32.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,130 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_base_w32.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//
-// Lock-free algorithm by Alexander Terekhov
-//
-// Thanks to Ben Hitchings for the #weak + (#shared != 0)
-// formulation
-//
-
-#include <boost/detail/interlocked.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/sp_typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-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)
-
-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
-
- // destroy() is called when weak_count_ drops to zero.
-
- virtual void destroy() // nothrow
- {
- delete this;
- }
-
- virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-
- void add_ref_copy()
- {
- BOOST_INTERLOCKED_INCREMENT( &use_count_ );
- }
-
- bool add_ref_lock() // true on success
- {
- for( ;; )
- {
- long tmp = static_cast< long const volatile& >( use_count_ );
- if( tmp == 0 ) return false;
-
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1200 )
-
- // work around a code generation bug
-
- long tmp2 = tmp + 1;
- if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
-
-#else
-
- if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
-
-#endif
- }
- }
-
- void release() // nothrow
- {
- if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
- {
- dispose();
- weak_release();
- }
- }
-
- void weak_add_ref() // nothrow
- {
- BOOST_INTERLOCKED_INCREMENT( &weak_count_ );
- }
-
- void weak_release() // nothrow
- {
- if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
- {
- destroy();
- }
- }
-
- long use_count() const // nothrow
- {
- return static_cast<long const volatile &>( use_count_ );
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED

Deleted: branches/release/boost/detail/sp_counted_impl.hpp
==============================================================================
--- branches/release/boost/detail/sp_counted_impl.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,231 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// detail/sp_counted_impl.hpp
-//
-// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-// Copyright 2004-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/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/detail/sp_counted_base.hpp>
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-#include <memory> // std::allocator
-#endif
-
-#include <cstddef> // std::size_t
-
-namespace boost
-{
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );
-void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
-
-#endif
-
-namespace detail
-{
-
-template<class X> class sp_counted_impl_p: public sp_counted_base
-{
-private:
-
- X * px_;
-
- sp_counted_impl_p( sp_counted_impl_p const & );
- sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
-
- typedef sp_counted_impl_p<X> this_type;
-
-public:
-
- explicit sp_counted_impl_p( X * px ): px_( px )
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_constructor_hook( px, sizeof(X), this );
-#endif
- }
-
- virtual void dispose() // nothrow
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
-#endif
- boost::checked_delete( px_ );
- }
-
- virtual void * get_deleter( detail::sp_typeinfo const & )
- {
- return 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
-};
-
-//
-// 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_impl_pd: public sp_counted_base
-{
-private:
-
- P ptr; // copy constructor must not throw
- D del; // copy constructor must not throw
-
- sp_counted_impl_pd( sp_counted_impl_pd const & );
- sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
-
- typedef sp_counted_impl_pd<P, D> this_type;
-
-public:
-
- // pre: d(p) must not throw
-
- sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
- {
- }
-
- virtual void dispose() // nothrow
- {
- del( ptr );
- }
-
- virtual void * get_deleter( detail::sp_typeinfo const & ti )
- {
- return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( 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
-};
-
-template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
-{
-private:
-
- P p_; // copy constructor must not throw
- D d_; // copy constructor must not throw
- A a_; // copy constructor must not throw
-
- sp_counted_impl_pda( sp_counted_impl_pda const & );
- sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
-
- typedef sp_counted_impl_pda<P, D, A> this_type;
-
-public:
-
- // pre: d( p ) must not throw
-
- sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
- {
- }
-
- virtual void dispose() // nothrow
- {
- d_( p_ );
- }
-
- virtual void destroy() // nothrow
- {
- typedef typename A::template rebind< this_type >::other A2;
-
- A2 a2( a_ );
-
- this->~this_type();
- a2.deallocate( this, 1 );
- }
-
- virtual void * get_deleter( detail::sp_typeinfo const & ti )
- {
- return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
- }
-};
-
-#ifdef __CODEGUARD__
-# pragma option pop
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock.hpp
==============================================================================
--- branches/release/boost/detail/spinlock.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,47 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/detail/spinlock.hpp
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// struct spinlock
-// {
-// void lock();
-// bool try_lock();
-// void unlock();
-//
-// class scoped_lock;
-// };
-//
-// #define BOOST_DETAIL_SPINLOCK_INIT <unspecified>
-//
-
-#include <boost/config.hpp>
-
-#if defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
-# include <boost/detail/spinlock_gcc_arm.hpp>
-#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
-# include <boost/detail/spinlock_sync.hpp>
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-# include <boost/detail/spinlock_w32.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
-# include <boost/detail/spinlock_pt.hpp>
-#elif !defined(BOOST_HAS_THREADS)
-# include <boost/detail/spinlock_nt.hpp>
-#else
-# error Unrecognized threading platform
-#endif
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_gcc_arm.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_gcc_arm.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,85 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
-
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/yield_k.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
- int v_;
-
-public:
-
- bool try_lock()
- {
- int r;
-
- __asm__ __volatile__(
- "swp %0, %1, [%2]":
- "=&r"( r ): // outputs
- "r"( 1 ), "r"( &v_ ): // inputs
- "memory", "cc" );
-
- return r == 0;
- }
-
- void lock()
- {
- for( unsigned k = 0; !try_lock(); ++k )
- {
- boost::detail::yield( k );
- }
- }
-
- void unlock()
- {
- __asm__ __volatile__( "" ::: "memory" );
- *const_cast< int volatile* >( &v_ ) = 0;
- }
-
-public:
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( spinlock & sp ): sp_( sp )
- {
- sp.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT {0}
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_nt.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_nt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,89 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/assert.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
- bool locked_;
-
-public:
-
- inline bool try_lock()
- {
- if( locked_ )
- {
- return false;
- }
- else
- {
- locked_ = true;
- return true;
- }
- }
-
- inline void lock()
- {
- BOOST_ASSERT( !locked_ );
- locked_ = true;
- }
-
- inline void unlock()
- {
- BOOST_ASSERT( locked_ );
- locked_ = false;
- }
-
-public:
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( spinlock & sp ): sp_( sp )
- {
- sp.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT { false }
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_pool.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_pool.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,87 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/detail/spinlock_pool.hpp
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// spinlock_pool<0> is reserved for atomic<>, when/if it arrives
-// spinlock_pool<1> is reserved for shared_ptr reference counts
-// spinlock_pool<2> is reserved for shared_ptr atomic access
-//
-
-#include <boost/config.hpp>
-#include <boost/detail/spinlock.hpp>
-#include <cstddef>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< int I > class spinlock_pool
-{
-private:
-
- static spinlock pool_[ 41 ];
-
-public:
-
- static spinlock & spinlock_for( void const * pv )
- {
- std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
- return pool_[ i ];
- }
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
- {
- sp_.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-template< int I > spinlock spinlock_pool::pool_[ 41 ] =
-{
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
- BOOST_DETAIL_SPINLOCK_INIT
-};
-
-} // namespace detail
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_pt.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_pt.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,79 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <pthread.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
- pthread_mutex_t v_;
-
-public:
-
- bool try_lock()
- {
- return pthread_mutex_trylock( &v_ ) == 0;
- }
-
- void lock()
- {
- pthread_mutex_lock( &v_ );
- }
-
- void unlock()
- {
- pthread_mutex_unlock( &v_ );
- }
-
-public:
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( spinlock & sp ): sp_( sp )
- {
- sp.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT { PTHREAD_MUTEX_INITIALIZER }
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_sync.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_sync.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,87 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/yield_k.hpp>
-
-#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
-# include <ia64intrin.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
- int v_;
-
-public:
-
- bool try_lock()
- {
- int r = __sync_lock_test_and_set( &v_, 1 );
- return r == 0;
- }
-
- void lock()
- {
- for( unsigned k = 0; !try_lock(); ++k )
- {
- boost::detail::yield( k );
- }
- }
-
- void unlock()
- {
- __sync_lock_release( &v_ );
- }
-
-public:
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( spinlock & sp ): sp_( sp )
- {
- sp.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT {0}
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED

Deleted: branches/release/boost/detail/spinlock_w32.hpp
==============================================================================
--- branches/release/boost/detail/spinlock_w32.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,113 +0,0 @@
-#ifndef BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED
-#define BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/detail/interlocked.hpp>
-#include <boost/detail/yield_k.hpp>
-
-// BOOST_COMPILER_FENCE
-
-#if defined(__INTEL_COMPILER)
-
-#define BOOST_COMPILER_FENCE __memory_barrier();
-
-#elif defined( _MSC_VER ) && _MSC_VER >= 1310
-
-extern "C" void _ReadWriteBarrier();
-#pragma intrinsic( _ReadWriteBarrier )
-
-#define BOOST_COMPILER_FENCE _ReadWriteBarrier();
-
-#elif defined(__GNUC__)
-
-#define BOOST_COMPILER_FENCE __asm__ __volatile__( "" : : : "memory" );
-
-#else
-
-#define BOOST_COMPILER_FENCE
-
-#endif
-
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
- long v_;
-
-public:
-
- bool try_lock()
- {
- long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 );
-
- BOOST_COMPILER_FENCE
-
- return r == 0;
- }
-
- void lock()
- {
- for( unsigned k = 0; !try_lock(); ++k )
- {
- boost::detail::yield( k );
- }
- }
-
- void unlock()
- {
- BOOST_COMPILER_FENCE
- *const_cast< long volatile* >( &v_ ) = 0;
- }
-
-public:
-
- class scoped_lock
- {
- private:
-
- spinlock & sp_;
-
- scoped_lock( scoped_lock const & );
- scoped_lock & operator=( scoped_lock const & );
-
- public:
-
- explicit scoped_lock( spinlock & sp ): sp_( sp )
- {
- sp.lock();
- }
-
- ~scoped_lock()
- {
- sp_.unlock();
- }
- };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT {0}
-
-#endif // #ifndef BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED

Deleted: branches/release/boost/detail/yield_k.hpp
==============================================================================
--- branches/release/boost/detail/yield_k.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
+++ (empty file)
@@ -1,149 +0,0 @@
-#ifndef BOOST_DETAIL_YIELD_K_HPP_INCLUDED
-#define BOOST_DETAIL_YIELD_K_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/detail/yield_k.hpp
-//
-// Copyright (c) 2008 Peter Dimov
-//
-// void yield( unsigned k );
-//
-// Typical use:
-//
-// for( unsigned k = 0; !try_lock(); ++k ) yield( k );
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-//
-
-#include <boost/config.hpp>
-
-// BOOST_SMT_PAUSE
-
-#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
-
-extern "C" void _mm_pause();
-#pragma intrinsic( _mm_pause )
-
-#define BOOST_SMT_PAUSE _mm_pause();
-
-#elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
-
-#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
-
-#endif
-
-//
-
-#if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
-
-#if defined( BOOST_USE_WINDOWS_H )
-# include <windows.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if !defined( BOOST_USE_WINDOWS_H )
- extern "C" void __stdcall Sleep( unsigned ms );
-#endif
-
-inline void yield( unsigned k )
-{
- if( k < 4 )
- {
- }
-#if defined( BOOST_SMT_PAUSE )
- else if( k < 16 )
- {
- BOOST_SMT_PAUSE
- }
-#endif
- else if( k < 32 )
- {
- Sleep( 0 );
- }
- else
- {
- Sleep( 1 );
- }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#elif defined( BOOST_HAS_PTHREADS )
-
-#include <sched.h>
-#include <time.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void yield( unsigned k )
-{
- if( k < 4 )
- {
- }
-#if defined( BOOST_SMT_PAUSE )
- else if( k < 16 )
- {
- BOOST_SMT_PAUSE
- }
-#endif
- else if( k < 32 || k & 1 )
- {
- sched_yield();
- }
- else
- {
- // g++ -Wextra warns on {} or {0}
- struct timespec rqtp = { 0, 0 };
-
- // POSIX says that timespec has tv_sec and tv_nsec
- // But it doesn't guarantee order or placement
-
- rqtp.tv_sec = 0;
- rqtp.tv_nsec = 1000;
-
- nanosleep( &rqtp, 0 );
- }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#else
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void yield( unsigned )
-{
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#endif
-
-#endif // #ifndef BOOST_DETAIL_YIELD_K_HPP_INCLUDED

Modified: branches/release/boost/enable_shared_from_this.hpp
==============================================================================
--- branches/release/boost/enable_shared_from_this.hpp (original)
+++ branches/release/boost/enable_shared_from_this.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -6,68 +6,13 @@
//
// Copyright (c) 2002 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
//

-#include <boost/weak_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-namespace boost
-{
-
-template<class T> class enable_shared_from_this
-{
-protected:
-
- enable_shared_from_this()
- {
- }
-
- enable_shared_from_this(enable_shared_from_this const &)
- {
- }
-
- enable_shared_from_this & operator=(enable_shared_from_this const &)
- {
- return *this;
- }
-
- ~enable_shared_from_this()
- {
- }
-
-public:
-
- shared_ptr<T> shared_from_this()
- {
- shared_ptr<T> p(_internal_weak_this);
- BOOST_ASSERT(p.get() == this);
- return p;
- }
-
- shared_ptr<T const> shared_from_this() const
- {
- shared_ptr<T const> p(_internal_weak_this);
- BOOST_ASSERT(p.get() == this);
- return p;
- }
-
-// Note: No, you don't need to initialize _internal_weak_this
-//
-// Please read the documentation, not the code
-//
-// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
-
- typedef T _internal_element_type; // for bcc 5.5.1
- mutable weak_ptr<_internal_element_type> _internal_weak_this;
-};
-
-} // namespace boost
+#include <boost/smart_ptr/enable_shared_from_this.hpp>

#endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED

Modified: branches/release/boost/intrusive_ptr.hpp
==============================================================================
--- branches/release/boost/intrusive_ptr.hpp (original)
+++ branches/release/boost/intrusive_ptr.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -6,306 +6,13 @@
//
// Copyright (c) 2001, 2002 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
//

-#include <boost/config.hpp>
-
-#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/sp_convertible.hpp>
-
-#include <boost/config/no_tr1/functional.hpp> // for std::less
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
-#include <iosfwd> // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
-
-namespace boost
-{
-
-//
-// intrusive_ptr
-//
-// A smart pointer that uses intrusive reference counting.
-//
-// Relies on unqualified calls to
-//
-// void intrusive_ptr_add_ref(T * p);
-// void intrusive_ptr_release(T * p);
-//
-// (p != 0)
-//
-// The object is responsible for destroying itself.
-//
-
-template<class T> class intrusive_ptr
-{
-private:
-
- typedef intrusive_ptr this_type;
-
-public:
-
- 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<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- intrusive_ptr( intrusive_ptr const & rhs, typename detail::sp_enable_if_convertible<U,T>::type = detail::sp_empty() )
-
-#else
-
- intrusive_ptr( intrusive_ptr const & rhs )
-
-#endif
- : 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<class U> 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;
- }
-
- void reset()
- {
- this_type().swap( *this );
- }
-
- void reset( T * rhs )
- {
- this_type( rhs ).swap( *this );
- }
-
- T * get() const
- {
- return p_;
- }
-
- T & operator*() const
- {
- BOOST_ASSERT( p_ != 0 );
- return *p_;
- }
-
- T * operator->() const
- {
- BOOST_ASSERT( p_ != 0 );
- 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<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
-{
- return a.get() == b;
-}
-
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
-{
- return a.get() != b;
-}
-
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr const & b)
-{
- return a == b.get();
-}
-
-template<class T, class U> 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<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
-{
- return a.get() != b.get();
-}
-
-#endif
-
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
-{
- return std::less<T *>()(a.get(), b.get());
-}
-
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
-{
- lhs.swap(rhs);
-}
-
-// mem_fn support
-
-template<class T> T * get_pointer(intrusive_ptr<T> const & p)
-{
- return p.get();
-}
-
-template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr const & p)
-{
- return static_cast<T *>(p.get());
-}
-
-template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr const & p)
-{
- return const_cast<T *>(p.get());
-}
-
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr const & p)
-{
- return dynamic_cast<T *>(p.get());
-}
-
-// operator<<
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) )
-
-template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
-{
- os << p.get();
- return os;
-}
-
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# else
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# endif
-{
- os << p.get();
- return os;
-}
-
-#endif // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
+#include <boost/smart_ptr/intrusive_ptr.hpp>

#endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED

Modified: branches/release/boost/make_shared.hpp
==============================================================================
--- branches/release/boost/make_shared.hpp (original)
+++ branches/release/boost/make_shared.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -12,422 +12,6 @@
// See http://www.boost.org/libs/smart_ptr/make_shared.html
// for documentation.

-#include <boost/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <cstddef>
-#include <new>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< std::size_t N, std::size_t A > struct sp_aligned_storage
-{
- union type
- {
- char data_[ N ];
- typename boost::type_with_alignment< A >::type align_;
- };
-};
-
-template< class T > class sp_ms_deleter
-{
-private:
-
- typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
-
- bool initialized_;
- storage_type storage_;
-
-private:
-
- void destroy()
- {
- if( initialized_ )
- {
- reinterpret_cast< T* >( storage_.data_ )->~T();
- initialized_ = false;
- }
- }
-
-public:
-
- sp_ms_deleter(): initialized_( false )
- {
- }
-
- ~sp_ms_deleter()
- {
- destroy();
- }
-
- void operator()( T * )
- {
- destroy();
- }
-
- void * address()
- {
- return storage_.data_;
- }
-
- void set_initialized()
- {
- initialized_ = true;
- }
-};
-
-template< class T > T forward( T t )
-{
- return t;
-}
-
-} // namespace detail
-
-// Zero-argument versions
-//
-// Used even when variadic templates are available because of the new T() vs new T issue
-
-template< class T > boost::shared_ptr< T > make_shared()
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T();
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T();
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
-
-// Variadic templates, rvalue reference
-
-template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( detail::forward<Args>( args )... );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Args && ... args )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( detail::forward<Args>( args )... );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-#else
-
-// C++03 version
-
-template< class T, class A1 >
-boost::shared_ptr< T > make_shared( A1 const & a1 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
-{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
-
- detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
-
- void * pv = pd->address();
-
- new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
- pd->set_initialized();
-
- return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
-}
-
-#endif
-
-} // namespace boost
+#include <boost/smart_ptr/make_shared.hpp>

#endif // #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED

Modified: branches/release/boost/scoped_array.hpp
==============================================================================
--- branches/release/boost/scoped_array.hpp (original)
+++ branches/release/boost/scoped_array.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -11,128 +11,6 @@
// http://www.boost.org/libs/smart_ptr/scoped_array.htm
//

-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/config.hpp> // in case ptrdiff_t not in std
-
-#include <boost/detail/workaround.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-
-namespace boost
-{
-
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_array_constructor_hook(void * p);
-void sp_array_destructor_hook(void * p);
-
-#endif
-
-// scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
-// is guaranteed, either on destruction of the scoped_array or via an explicit
-// reset(). Use shared_array or std::vector if your needs are more complex.
-
-template<class T> class scoped_array // noncopyable
-{
-private:
-
- T * ptr;
-
- scoped_array(scoped_array const &);
- scoped_array & operator=(scoped_array const &);
-
- typedef scoped_array<T> this_type;
-
- void operator==( scoped_array const& ) const;
- void operator!=( scoped_array const& ) const;
-
-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<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
-{
- a.swap(b);
-}
-
-} // namespace boost
+#include <boost/smart_ptr/scoped_array.hpp>

#endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED

Modified: branches/release/boost/scoped_ptr.hpp
==============================================================================
--- branches/release/boost/scoped_ptr.hpp (original)
+++ branches/release/boost/scoped_ptr.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -11,150 +11,6 @@
// http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
//

-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory> // for std::auto_ptr
-#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 T> class scoped_ptr // noncopyable
-{
-private:
-
- T * ptr;
-
- scoped_ptr(scoped_ptr const &);
- scoped_ptr & operator=(scoped_ptr const &);
-
- typedef scoped_ptr<T> this_type;
-
- void operator==( scoped_ptr const& ) const;
- void operator!=( scoped_ptr const& ) const;
-
-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<T> p): ptr(p.release()) // never throws
- {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
- boost::sp_scalar_constructor_hook(ptr);
-#endif
- }
-
-#endif
-
- ~scoped_ptr() // never throws
- {
-#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<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
-{
- a.swap(b);
-}
-
-// get_pointer(p) is a generic way to say p.get()
-
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
-{
- return p.get();
-}
-
-} // namespace boost
+#include <boost/smart_ptr/scoped_ptr.hpp>

#endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED

Modified: branches/release/boost/shared_array.hpp
==============================================================================
--- branches/release/boost/shared_array.hpp (original)
+++ branches/release/boost/shared_array.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -14,180 +14,6 @@
// See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
//

-#include <boost/config.hpp> // for broken compiler workarounds
-
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/detail/shared_array_nmt.hpp>
-#else
-
-#include <memory> // TR1 cyclic inclusion fix
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-
-#include <boost/detail/shared_count.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-
-namespace boost
-{
-
-//
-// shared_array
-//
-// shared_array extends shared_ptr to arrays.
-// The array pointed to is deleted when the last shared_array pointing to it
-// is destroyed or reset.
-//
-
-template<class T> class shared_array
-{
-private:
-
- // Borland 5.5.1 specific workarounds
- typedef checked_array_deleter<T> deleter;
- typedef shared_array<T> this_type;
-
-public:
-
- typedef T element_type;
-
- explicit shared_array(T * p = 0): px(p), pn(p, deleter())
- {
- }
-
- //
- // Requirements: D's copy constructor must not throw
- //
- // shared_array will release p by calling d(p)
- //
-
- template<class D> shared_array(T * p, D d): px(p), pn(p, d)
- {
- }
-
-// generated copy constructor, assignment, destructor are fine
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- this_type(p).swap(*this);
- }
-
- template <class D> void reset(T * p, D d)
- {
- this_type(p, d).swap(*this);
- }
-
- T & operator[] (std::ptrdiff_t i) const // never throws
- {
- BOOST_ASSERT(px != 0);
- BOOST_ASSERT(i >= 0);
- return px[i];
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
- operator bool () const
- {
- return px != 0;
- }
-
-#elif defined( _MANAGED )
-
- static void unspecified_bool( this_type*** )
- {
- }
-
- typedef void (*unspecified_bool_type)( this_type*** );
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: unspecified_bool;
- }
-
-#elif \
- ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
- ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) )
-
- 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<T> & other) // never throws
- {
- std::swap(px, other.px);
- pn.swap(other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- detail::shared_count pn; // reference counter
-
-}; // shared_array
-
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return a.get() == b.get();
-}
-
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/smart_ptr/shared_array.hpp>

#endif // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED

Modified: branches/release/boost/shared_ptr.hpp
==============================================================================
--- branches/release/boost/shared_ptr.hpp (original)
+++ branches/release/boost/shared_ptr.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -14,738 +14,6 @@
// 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
-
-// In order to avoid circular dependencies with Boost.TR1
-// we make sure that our include of <memory> doesn't try to
-// pull in the TR1 headers: that's why we use this header
-// rather than including <memory> directly:
-#include <boost/config/no_tr1/memory.hpp> // std::auto_ptr
-
-#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 <boost/detail/sp_convertible.hpp>
-
-#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
-#include <boost/detail/spinlock_pool.hpp>
-#include <boost/memory_order.hpp>
-#endif
-
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <typeinfo> // for std::bad_cast
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
-#include <iosfwd> // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
-#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( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
-{
- if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
-}
-
-#ifdef _MANAGED
-
-// Avoid C4793, ... causes native code generation
-
-struct sp_any_pointer
-{
- template<class T> sp_any_pointer( T* ) {}
-};
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, sp_any_pointer, sp_any_pointer )
-{
-}
-
-#else // _MANAGED
-
-#ifdef sgi
-// Turn off: the last argument of the varargs function "sp_enable_shared_from_this" is unnamed
-# pragma set woff 3506
-#endif
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
-{
-}
-
-#ifdef sgi
-# pragma reset woff 3506
-#endif
-
-#endif // _MANAGED
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )
-
-// rvalue auto_ptr support based on a technique by Dave Abrahams
-
-template< class T, class R > struct sp_enable_if_auto_ptr
-{
-};
-
-template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
-{
- typedef R type;
-};
-
-#endif
-
-} // namespace detail
-
-
-//
-// shared_ptr
-//
-// An enhanced relative of scoped_ptr with reference counted copy semantics.
-// The object pointed to is deleted when the last shared_ptr pointing to it
-// is destroyed or reset.
-//
-
-template<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 boost::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 ) // Y must be complete
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
- //
- // 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)
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
- // As above, but with allocator. A's copy constructor shall not throw.
-
- template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
- {
- boost::detail::sp_enable_shared_from_this( pn, p, p );
- }
-
-// 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( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
- {
- if( !pn.empty() )
- {
- px = r.px;
- }
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- shared_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- shared_ptr( shared_ptr<Y> const & r )
-
-#endif
- : px( r.px ), pn( r.pn ) // never throws
- {
- }
-
- // aliasing
- template< class Y >
- shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn ) // never throws
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
- {
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::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 = boost::detail::shared_count();
- }
- }
-
- template<class Y>
- shared_ptr(shared_ptr<Y> const & r, boost::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 = boost::detail::shared_count(r);
- boost::detail::sp_enable_shared_from_this( pn, tmp, tmp );
- }
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
- template<class Ap>
- shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
- {
- typename Ap::element_type * tmp = r.get();
- pn = boost::detail::shared_count( r );
- boost::detail::sp_enable_shared_from_this( pn, tmp, tmp );
- }
-
-
-#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // BOOST_NO_AUTO_PTR
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
- 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;
- }
-
-#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
- template<class Ap>
- typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
- {
- this_type( r ).swap( *this );
- return *this;
- }
-
-
-#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#endif // BOOST_NO_AUTO_PTR
-
-// Move support
-
-#if defined( BOOST_HAS_RVALUE_REFS )
-
- shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
- {
- pn.swap( r.pn );
- r.px = 0;
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- shared_ptr( shared_ptr<Y> && r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- shared_ptr( shared_ptr<Y> && r )
-
-#endif
- : px( r.px ), pn() // never throws
- {
- pn.swap( r.pn );
- r.px = 0;
- }
-
- shared_ptr & operator=( shared_ptr && r ) // never throws
- {
- this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
- return *this;
- }
-
- template<class Y>
- shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
- {
- this_type( static_cast< shared_ptr<Y> && >( 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 );
- }
-
- template<class Y, class D, class A> void reset( Y * p, D d, A a )
- {
- this_type( p, d, a ).swap( *this );
- }
-
- template<class Y> void reset( shared_ptr<Y> const & r, T * p )
- {
- this_type( r, p ).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, < 0x570) ) || defined(__CINT__)
-
- operator bool () const
- {
- return px != 0;
- }
-
-#elif defined( _MANAGED )
-
- static void unspecified_bool( this_type*** )
- {
- }
-
- typedef void (*unspecified_bool_type)( this_type*** );
-
- operator unspecified_bool_type() const // never throws
- {
- return px == 0? 0: unspecified_bool;
- }
-
-#elif \
- ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
- ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
- ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
-
- 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( detail::sp_typeinfo const & ti ) const
- {
- return pn.get_deleter( ti );
- }
-
- bool _internal_equiv( shared_ptr const & r ) const
- {
- return px == r.px && pn == r.pn;
- }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
- template<class Y> friend class shared_ptr;
- template<class Y> friend class weak_ptr;
-
-
-#endif
-
- T * px; // contained pointer
- boost::detail::shared_count pn; // reference counter
-
-}; // shared_ptr
-
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr 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 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 const & r)
-{
- return shared_ptr<T>(r, boost::detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr const & r)
-{
- return shared_ptr<T>(r, boost::detail::const_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr const & r)
-{
- return shared_ptr<T>(r, boost::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 const & r)
-{
- return shared_ptr<T>(r, boost::detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr const & r)
-{
- return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr const & r)
-{
- return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
-}
-
-template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr 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(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) )
-
-template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
-{
- os << p.get();
- return os;
-}
-
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __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 // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-// get_deleter
-
-#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
- ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
- ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
-
-template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
-{
- void const * q = p._internal_get_deleter(BOOST_SP_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(BOOST_SP_TYPEID(D)));
-}
-
-#endif
-
-// atomic access
-
-#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
-
-template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
-{
- return false;
-}
-
-template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
-{
- boost::detail::spinlock_pool<2>::scoped_lock lock( p );
- return *p;
-}
-
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
-{
- return atomic_load( p );
-}
-
-template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
-{
- boost::detail::spinlock_pool<2>::scoped_lock lock( p );
- p->swap( r );
-}
-
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
-{
- atomic_store( p, r ); // std::move( r )
-}
-
-template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
-{
- boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
-
- sp.lock();
- p->swap( r );
- sp.unlock();
-
- return r; // return std::move( r )
-}
-
-template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
-{
- return atomic_exchange( p, r ); // std::move( r )
-}
-
-template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
-{
- boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
-
- sp.lock();
-
- if( p->_internal_equiv( *v ) )
- {
- p->swap( w );
-
- sp.unlock();
-
- return true;
- }
- else
- {
- shared_ptr<T> tmp( *p );
-
- sp.unlock();
-
- tmp.swap( *v );
- return false;
- }
-}
-
-template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
-{
- return atomic_compare_exchange( p, v, w ); // std::move( w )
-}
-
-#endif
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/smart_ptr/shared_ptr.hpp>

#endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED

Modified: branches/release/boost/weak_ptr.hpp
==============================================================================
--- branches/release/boost/weak_ptr.hpp (original)
+++ branches/release/boost/weak_ptr.hpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -6,177 +6,13 @@
//
// Copyright (c) 2001, 2002, 2003 Peter Dimov
//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
//
// See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
//

-#include <memory> // boost.TR1 include order fix
-#include <boost/detail/shared_count.hpp>
-#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>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- weak_ptr( weak_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- weak_ptr( weak_ptr<Y> const & r )
-
-#endif
- : pn(r.pn) // never throws
- {
- px = r.lock().get();
- }
-
- template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
- weak_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
-
-#else
-
- weak_ptr( shared_ptr<Y> const & r )
-
-#endif
- : px( r.px ), pn( r.pn ) // never throws
- {
- }
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
- 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
- {
- return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
- }
-
- 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, boost::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)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
- template<class Y> friend class weak_ptr;
- template<class Y> friend class shared_ptr;
-
-#endif
-
- T * px; // contained pointer
- boost::detail::weak_count pn; // reference counter
-
-}; // weak_ptr
-
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr const & b)
-{
- return a._internal_less(b);
-}
-
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
+#include <boost/smart_ptr/weak_ptr.hpp>

#endif // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED

Modified: branches/release/libs/smart_ptr/test/spinlock_pool_test.cpp
==============================================================================
--- branches/release/libs/smart_ptr/test/spinlock_pool_test.cpp (original)
+++ branches/release/libs/smart_ptr/test/spinlock_pool_test.cpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -8,7 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt
//

-#include <boost/detail/spinlock_pool.hpp>
+#include <boost/smart_ptr/detail/spinlock_pool.hpp>

// Sanity check only

Modified: branches/release/libs/smart_ptr/test/spinlock_test.cpp
==============================================================================
--- branches/release/libs/smart_ptr/test/spinlock_test.cpp (original)
+++ branches/release/libs/smart_ptr/test/spinlock_test.cpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -8,7 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//

-#include <boost/detail/spinlock.hpp>
+#include <boost/smart_ptr/detail/spinlock.hpp>

// Sanity check only

Modified: branches/release/libs/smart_ptr/test/spinlock_try_test.cpp
==============================================================================
--- branches/release/libs/smart_ptr/test/spinlock_try_test.cpp (original)
+++ branches/release/libs/smart_ptr/test/spinlock_try_test.cpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -8,7 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//

-#include <boost/detail/spinlock.hpp>
+#include <boost/smart_ptr/detail/spinlock.hpp>
#include <boost/detail/lightweight_test.hpp>

// Sanity check only

Modified: branches/release/libs/smart_ptr/test/yield_k_test.cpp
==============================================================================
--- branches/release/libs/smart_ptr/test/yield_k_test.cpp (original)
+++ branches/release/libs/smart_ptr/test/yield_k_test.cpp 2009-03-02 11:22:16 EST (Mon, 02 Mar 2009)
@@ -8,7 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//

-#include <boost/detail/yield_k.hpp>
+#include <boost/smart_ptr/detail/yield_k.hpp>

// Sanity check only

Next message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r51532 - branches/release/boost/bind"
Previous message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r51530 - in branches/release/boost: . bind"

Date view	Thread view	Subject view	Author view