#ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED | |
#define BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED | |
// | |
// intrusive_ptr.hpp | |
// | |
// 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/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/smart_ptr/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(): px( 0 ) | |
{ | |
} | |
intrusive_ptr( T * p, bool add_ref = true ): px( p ) | |
{ | |
if( px != 0 && add_ref ) intrusive_ptr_add_ref( px ); | |
} | |
#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<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() ) | |
#else | |
intrusive_ptr( intrusive_ptr<U> const & rhs ) | |
#endif | |
: px( rhs.get() ) | |
{ | |
if( px != 0 ) intrusive_ptr_add_ref( px ); | |
} | |
#endif | |
intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px ) | |
{ | |
if( px != 0 ) intrusive_ptr_add_ref( px ); | |
} | |
~intrusive_ptr() | |
{ | |
if( px != 0 ) intrusive_ptr_release( px ); | |
} | |
#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) | |
template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs) | |
{ | |
this_type(rhs).swap(*this); | |
return *this; | |
} | |
#endif | |
// Move support | |
#if defined( BOOST_HAS_RVALUE_REFS ) | |
intrusive_ptr(intrusive_ptr && rhs): px( rhs.px ) | |
{ | |
rhs.px = 0; | |
} | |
intrusive_ptr & operator=(intrusive_ptr && rhs) | |
{ | |
this_type( static_cast< intrusive_ptr && >( 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 px; | |
} | |
T & operator*() const | |
{ | |
BOOST_ASSERT( px != 0 ); | |
return *px; | |
} | |
T * operator->() const | |
{ | |
BOOST_ASSERT( px != 0 ); | |
return px; | |
} | |
// implicit conversion to "bool" | |
#include <boost/smart_ptr/detail/operator_bool.hpp> | |
void swap(intrusive_ptr & rhs) | |
{ | |
T * tmp = px; | |
px = rhs.px; | |
rhs.px = tmp; | |
} | |
private: | |
T * px; | |
}; | |
template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) | |
{ | |
return a.get() == b.get(); | |
} | |
template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) | |
{ | |
return a.get() != b.get(); | |
} | |
template<class T, 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<U> const & b) | |
{ | |
return a == b.get(); | |
} | |
template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> 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<U> const & p) | |
{ | |
return static_cast<T *>(p.get()); | |
} | |
template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p) | |
{ | |
return const_cast<T *>(p.get()); | |
} | |
template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> 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 | |
#endif // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED |