mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-12-15 01:41:43 +00:00
c2f99181e6
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26648 a592a061-630c-0410-9148-cb99ea01b6c8
312 lines
6.6 KiB
C++
312 lines
6.6 KiB
C++
#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
|
|
#define BOOST_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/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<U> const & rhs, typename detail::sp_enable_if_convertible<U,T>::type = detail::sp_empty() )
|
|
|
|
#else
|
|
|
|
intrusive_ptr( intrusive_ptr<U> 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<U> 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<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_INTRUSIVE_PTR_HPP_INCLUDED
|