183 lines
3.9 KiB
C++
183 lines
3.9 KiB
C++
#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
|
|
#define BOOST_DETAIL_SHARED_PTR_NMT_132_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/serialization/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::serialization::throw_exception(std::bad_alloc());
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
~shared_ptr()
|
|
{
|
|
if(--*pn == 0)
|
|
{
|
|
boost::checked_delete(px);
|
|
delete pn;
|
|
}
|
|
}
|
|
|
|
shared_ptr(shared_ptr const & r): px(r.px) // never throws
|
|
{
|
|
pn = r.pn;
|
|
++*pn;
|
|
}
|
|
|
|
shared_ptr & operator=(shared_ptr const & r)
|
|
{
|
|
shared_ptr(r).swap(*this);
|
|
return *this;
|
|
}
|
|
|
|
#ifndef BOOST_NO_AUTO_PTR
|
|
|
|
explicit shared_ptr(std::auto_ptr< T > & r)
|
|
{
|
|
pn = new count_type(1); // may throw
|
|
px = r.release(); // fix: moved here to stop leak if new throws
|
|
}
|
|
|
|
shared_ptr & operator=(std::auto_ptr< T > & r)
|
|
{
|
|
shared_ptr(r).swap(*this);
|
|
return *this;
|
|
}
|
|
|
|
#endif
|
|
|
|
void reset(T * p = 0)
|
|
{
|
|
BOOST_ASSERT(p == 0 || p != px);
|
|
shared_ptr(p).swap(*this);
|
|
}
|
|
|
|
T & operator*() const // never throws
|
|
{
|
|
BOOST_ASSERT(px != 0);
|
|
return *px;
|
|
}
|
|
|
|
T * operator->() const // never throws
|
|
{
|
|
BOOST_ASSERT(px != 0);
|
|
return px;
|
|
}
|
|
|
|
T * get() const // never throws
|
|
{
|
|
return px;
|
|
}
|
|
|
|
long use_count() const // never throws
|
|
{
|
|
return *pn;
|
|
}
|
|
|
|
bool unique() const // never throws
|
|
{
|
|
return *pn == 1;
|
|
}
|
|
|
|
void swap(shared_ptr< T > & other) // never throws
|
|
{
|
|
std::swap(px, other.px);
|
|
std::swap(pn, other.pn);
|
|
}
|
|
|
|
private:
|
|
|
|
T * px; // contained pointer
|
|
count_type * pn; // ptr to reference counter
|
|
};
|
|
|
|
template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
|
|
{
|
|
return a.get() == b.get();
|
|
}
|
|
|
|
template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
|
|
{
|
|
return a.get() != b.get();
|
|
}
|
|
|
|
template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
|
|
{
|
|
return std::less<T*>()(a.get(), b.get());
|
|
}
|
|
|
|
template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
|
|
{
|
|
a.swap(b);
|
|
}
|
|
|
|
// get_pointer() enables boost::mem_fn to recognize shared_ptr
|
|
|
|
template<class T> inline T * get_pointer(shared_ptr< T > const & p)
|
|
{
|
|
return p.get();
|
|
}
|
|
|
|
} // namespace boost
|
|
|
|
#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
|