forked from boostorg/intrusive
Full merge from trunk at revision 41356 of entire boost-root tree.
[SVN r41370]
This commit is contained in:
Beman Dawes committed
1 parent
ccbfcebe9f
commit
cc749e440e
101 files changed
+16039
No files matched your search
@@ -0,0 +1,422 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2006. 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/intrusive for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_SMART_PTR_HPP
|
||||
#define BOOST_INTRUSIVE_SMART_PTR_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/intrusive/pointer_plus_bit.hpp>
|
||||
#include <boost/intrusive/pointer_plus_2_bits.hpp>
|
||||
|
||||
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
namespace intrusive{
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct static_cast_tag {};
|
||||
struct const_cast_tag {};
|
||||
struct dynamic_cast_tag {};
|
||||
struct reinterpret_cast_tag {};
|
||||
|
||||
} //namespace detail {
|
||||
|
||||
//Empty class
|
||||
struct empty_type{};
|
||||
|
||||
template<class T>
|
||||
struct random_it
|
||||
: public boost::iterator<std::random_access_iterator_tag,
|
||||
T, std::ptrdiff_t, T*, T&>
|
||||
{
|
||||
typedef const T* const_pointer;
|
||||
typedef const T& const_reference;
|
||||
};
|
||||
|
||||
template<> struct random_it<void>
|
||||
{
|
||||
typedef const void * const_pointer;
|
||||
typedef empty_type& reference;
|
||||
typedef const empty_type& const_reference;
|
||||
typedef empty_type difference_type;
|
||||
typedef empty_type iterator_category;
|
||||
};
|
||||
|
||||
template<> struct random_it<const void>
|
||||
{
|
||||
typedef const void * const_pointer;
|
||||
typedef const empty_type & reference;
|
||||
typedef const empty_type & const_reference;
|
||||
typedef empty_type difference_type;
|
||||
typedef empty_type iterator_category;
|
||||
};
|
||||
|
||||
template<> struct random_it<volatile void>
|
||||
{
|
||||
typedef const volatile void * const_pointer;
|
||||
typedef empty_type& reference;
|
||||
typedef const empty_type& const_reference;
|
||||
typedef empty_type difference_type;
|
||||
typedef empty_type iterator_category;
|
||||
};
|
||||
|
||||
template<> struct random_it<const volatile void>
|
||||
{
|
||||
typedef const volatile void * const_pointer;
|
||||
typedef const empty_type & reference;
|
||||
typedef const empty_type & const_reference;
|
||||
typedef empty_type difference_type;
|
||||
typedef empty_type iterator_category;
|
||||
};
|
||||
|
||||
} //namespace intrusive {
|
||||
} //namespace boost {
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace intrusive {
|
||||
|
||||
template <class PointedType>
|
||||
class smart_ptr
|
||||
{
|
||||
typedef random_it<PointedType> random_it_t;
|
||||
typedef smart_ptr<PointedType> self_t;
|
||||
typedef typename random_it_t::const_pointer const_pointer_t;
|
||||
typedef typename random_it_t::const_reference const_reference_t;
|
||||
|
||||
void unspecified_bool_type_func() const {}
|
||||
typedef void (self_t::*unspecified_bool_type)() const;
|
||||
|
||||
public:
|
||||
typedef PointedType * pointer;
|
||||
typedef typename random_it_t::reference reference;
|
||||
typedef PointedType value_type;
|
||||
typedef typename random_it_t::difference_type difference_type;
|
||||
typedef typename random_it_t::iterator_category iterator_category;
|
||||
|
||||
PointedType *m_ptr;
|
||||
|
||||
public: //Public Functions
|
||||
|
||||
//!Constructor from raw pointer (allows "0" pointer conversion). Never throws.
|
||||
smart_ptr(pointer ptr = 0)
|
||||
: m_ptr(ptr)
|
||||
{}
|
||||
|
||||
//!Constructor from other pointer. Never throws.
|
||||
template <class T>
|
||||
smart_ptr(T *ptr)
|
||||
: m_ptr(ptr)
|
||||
{}
|
||||
|
||||
//!Constructor from other smart_ptr
|
||||
smart_ptr(const smart_ptr& ptr)
|
||||
: m_ptr(ptr.m_ptr)
|
||||
{}
|
||||
|
||||
//!Constructor from other smart_ptr. If pointers of pointee types are
|
||||
//!convertible, offset_ptrs will be convertibles. Never throws.
|
||||
template<class T2>
|
||||
smart_ptr(const smart_ptr<T2> &ptr)
|
||||
: m_ptr(ptr.m_ptr)
|
||||
{}
|
||||
|
||||
//!Emulates static_cast operator. Never throws.
|
||||
template<class Y>
|
||||
smart_ptr(const smart_ptr<Y> & r, detail::static_cast_tag)
|
||||
: m_ptr(static_cast<PointedType*>(r.get()))
|
||||
{}
|
||||
|
||||
//!Emulates const_cast operator. Never throws.
|
||||
template<class Y>
|
||||
smart_ptr(const smart_ptr<Y> & r, detail::const_cast_tag)
|
||||
: m_ptr(const_cast<PointedType*>(r.get()))
|
||||
{}
|
||||
|
||||
//!Emulates dynamic_cast operator. Never throws.
|
||||
template<class Y>
|
||||
smart_ptr(const smart_ptr<Y> & r, detail::dynamic_cast_tag)
|
||||
: m_ptr(dynamic_cast<PointedType*>(r.get()))
|
||||
{}
|
||||
|
||||
//!Emulates reinterpret_cast operator. Never throws.
|
||||
template<class Y>
|
||||
smart_ptr(const smart_ptr<Y> & r, detail::reinterpret_cast_tag)
|
||||
: m_ptr(reinterpret_cast<PointedType*>(r.get()))
|
||||
{}
|
||||
|
||||
//!Obtains raw pointer from offset. Never throws.
|
||||
pointer get() const
|
||||
{ return m_ptr; }
|
||||
|
||||
//!Pointer-like -> operator. It can return 0 pointer. Never throws.
|
||||
pointer operator->() const
|
||||
{ return this->get(); }
|
||||
|
||||
//!Dereferencing operator, if it is a null smart_ptr behavior
|
||||
//! is undefined. Never throws.
|
||||
reference operator* () const
|
||||
{ return *(this->get()); }
|
||||
|
||||
//!Indexing operator. Never throws.
|
||||
reference operator[](std::ptrdiff_t idx) const
|
||||
{ return this->get()[idx]; }
|
||||
|
||||
//!Assignment from pointer (saves extra conversion). Never throws.
|
||||
smart_ptr& operator= (pointer from)
|
||||
{ m_ptr = from; return *this; }
|
||||
|
||||
//!Assignment from other smart_ptr. Never throws.
|
||||
smart_ptr& operator= (const smart_ptr & pt)
|
||||
{ m_ptr = pt.m_ptr; return *this; }
|
||||
|
||||
//!Assignment from related smart_ptr. If pointers of pointee types
|
||||
//! are assignable, offset_ptrs will be assignable. Never throws.
|
||||
template <class T2>
|
||||
smart_ptr& operator= (const smart_ptr<T2> & pt)
|
||||
{ m_ptr = pt.m_ptr; return *this; }
|
||||
|
||||
//!smart_ptr + std::ptrdiff_t. Never throws.
|
||||
smart_ptr operator+ (std::ptrdiff_t offset) const
|
||||
{ return smart_ptr(this->get()+offset); }
|
||||
|
||||
//!smart_ptr - std::ptrdiff_t. Never throws.
|
||||
smart_ptr operator- (std::ptrdiff_t offset) const
|
||||
{ return smart_ptr(this->get()-offset); }
|
||||
|
||||
//!smart_ptr += std::ptrdiff_t. Never throws.
|
||||
smart_ptr &operator+= (std::ptrdiff_t offset)
|
||||
{ m_ptr += offset; return *this; }
|
||||
|
||||
//!smart_ptr -= std::ptrdiff_t. Never throws.
|
||||
smart_ptr &operator-= (std::ptrdiff_t offset)
|
||||
{ m_ptr -= offset; return *this; }
|
||||
|
||||
//!++smart_ptr. Never throws.
|
||||
smart_ptr& operator++ (void)
|
||||
{ ++m_ptr; return *this; }
|
||||
|
||||
//!smart_ptr++. Never throws.
|
||||
smart_ptr operator++ (int)
|
||||
{ smart_ptr temp(*this); ++*this; return temp; }
|
||||
|
||||
//!--smart_ptr. Never throws.
|
||||
smart_ptr& operator-- (void)
|
||||
{ --m_ptr; return *this; }
|
||||
|
||||
//!smart_ptr--. Never throws.
|
||||
smart_ptr operator-- (int)
|
||||
{ smart_ptr temp(*this); --*this; return temp; }
|
||||
|
||||
//!safe bool conversion operator. Never throws.
|
||||
operator unspecified_bool_type() const
|
||||
{ return this->get()? &self_t::unspecified_bool_type_func : 0; }
|
||||
|
||||
//!Not operator. Not needed in theory, but improves portability.
|
||||
//!Never throws.
|
||||
bool operator! () const
|
||||
{ return this->get() == 0; }
|
||||
/*
|
||||
friend void swap (smart_ptr &pt, smart_ptr &pt2)
|
||||
{
|
||||
value_type *ptr = pt.get();
|
||||
pt = pt2;
|
||||
pt2 = ptr;
|
||||
}
|
||||
*/
|
||||
};
|
||||
|
||||
//!smart_ptr<T1> == smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator== (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() == pt2.get(); }
|
||||
|
||||
//!smart_ptr<T1> != smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator!= (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() != pt2.get(); }
|
||||
|
||||
//!smart_ptr<T1> < smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator< (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() < pt2.get(); }
|
||||
|
||||
//!smart_ptr<T1> <= smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator<= (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() <= pt2.get(); }
|
||||
|
||||
//!smart_ptr<T1> > smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator> (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() > pt2.get(); }
|
||||
|
||||
//!smart_ptr<T1> >= smart_ptr<T2>. Never throws.
|
||||
template<class T1, class T2>
|
||||
inline bool operator>= (const smart_ptr<T1> &pt1,
|
||||
const smart_ptr<T2> &pt2)
|
||||
{ return pt1.get() >= pt2.get(); }
|
||||
|
||||
//!operator<<
|
||||
template<class E, class T, class Y>
|
||||
inline std::basic_ostream<E, T> & operator<<
|
||||
(std::basic_ostream<E, T> & os, smart_ptr<Y> const & p)
|
||||
{ return os << p.get(); }
|
||||
|
||||
//!operator>>
|
||||
template<class E, class T, class Y>
|
||||
inline std::basic_istream<E, T> & operator>>
|
||||
(std::basic_istream<E, T> & os, smart_ptr<Y> & p)
|
||||
{ Y * tmp; return os >> tmp; p = tmp; }
|
||||
|
||||
//!std::ptrdiff_t + smart_ptr
|
||||
template<class T>
|
||||
inline smart_ptr<T> operator+(std::ptrdiff_t diff, const smart_ptr<T>& right)
|
||||
{ return right + diff; }
|
||||
|
||||
//!smart_ptr - smart_ptr
|
||||
template<class T, class T2>
|
||||
inline std::ptrdiff_t operator- (const smart_ptr<T> &pt, const smart_ptr<T2> &pt2)
|
||||
{ return pt.get()- pt2.get(); }
|
||||
|
||||
//!swap specialization
|
||||
template<class T>
|
||||
inline void swap (smart_ptr<T> &pt,
|
||||
smart_ptr<T> &pt2)
|
||||
{
|
||||
typename smart_ptr<T>::value_type *ptr = pt.get();
|
||||
pt = pt2;
|
||||
pt2 = ptr;
|
||||
}
|
||||
|
||||
//!detail::get_pointer() enables boost::mem_fn to recognize smart_ptr.
|
||||
//!Never throws.
|
||||
template<class T>
|
||||
inline T* get_pointer(const smart_ptr<T> & p)
|
||||
{ return p.get(); }
|
||||
|
||||
//!Simulation of static_cast between pointers. Never throws.
|
||||
template<class T, class U>
|
||||
inline smart_ptr<T>
|
||||
static_pointer_cast(smart_ptr<U> const & r)
|
||||
{
|
||||
return smart_ptr<T>(r, detail::static_cast_tag());
|
||||
}
|
||||
|
||||
//!Simulation of const_cast between pointers. Never throws.
|
||||
template<class T, class U>
|
||||
inline smart_ptr<T>const_pointer_cast(smart_ptr<U> const & r)
|
||||
{
|
||||
return smart_ptr<T>(r, detail::const_cast_tag());
|
||||
}
|
||||
|
||||
//!Simulation of dynamic_cast between pointers. Never throws.
|
||||
template<class T, class U>
|
||||
inline smart_ptr<T>
|
||||
dynamic_pointer_cast(smart_ptr<U> const & r)
|
||||
{
|
||||
return smart_ptr<T>
|
||||
(r, detail::dynamic_cast_tag());
|
||||
}
|
||||
|
||||
//!Simulation of reinterpret_cast between pointers. Never throws.
|
||||
template<class T, class U>
|
||||
inline smart_ptr<T>
|
||||
reinterpret_pointer_cast(smart_ptr<U> const & r)
|
||||
{
|
||||
return smart_ptr<T>(r, detail::reinterpret_cast_tag());
|
||||
}
|
||||
|
||||
} //namespace intrusive {
|
||||
} //namespace boost {
|
||||
|
||||
namespace boost{
|
||||
|
||||
//This is to support embedding a bit in the pointer
|
||||
//for intrusive containers, saving space
|
||||
namespace intrusive {
|
||||
|
||||
template<std::size_t N>
|
||||
struct has_pointer_plus_bit<smart_ptr<void>, N>
|
||||
{
|
||||
static const bool value = has_pointer_plus_bit<void*, N>::value;
|
||||
};
|
||||
|
||||
//Specialization
|
||||
template<class T>
|
||||
struct pointer_plus_bit<smart_ptr<T> >
|
||||
{
|
||||
typedef smart_ptr<T> pointer;
|
||||
|
||||
static pointer get_pointer(const pointer &n)
|
||||
{ return pointer_plus_bit<T*>::get_pointer(n.get()); }
|
||||
|
||||
static void set_pointer(pointer &n, pointer p)
|
||||
{
|
||||
T *raw_n = n.get();
|
||||
pointer_plus_bit<T*>::set_pointer(raw_n, p.get());
|
||||
n = raw_n;
|
||||
}
|
||||
|
||||
static bool get_bit(const pointer &n)
|
||||
{ return pointer_plus_bit<T*>::get_bit(n.get()); }
|
||||
|
||||
static void set_bit(pointer &n, bool c)
|
||||
{
|
||||
T *raw_n = n.get();
|
||||
pointer_plus_bit<T*>::set_bit(raw_n, c);
|
||||
n = raw_n;
|
||||
}
|
||||
};
|
||||
|
||||
template<std::size_t N>
|
||||
struct has_pointer_plus_2_bits<smart_ptr<void>, N>
|
||||
{
|
||||
static const bool value = has_pointer_plus_2_bits<void*, N>::value;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct pointer_plus_2_bits<smart_ptr<T> >
|
||||
{
|
||||
typedef smart_ptr<T> pointer;
|
||||
|
||||
static pointer get_pointer(const pointer &n)
|
||||
{ return pointer_plus_2_bits<T*>::get_pointer(n.get()); }
|
||||
|
||||
static void set_pointer(pointer &n, pointer p)
|
||||
{
|
||||
T *raw_n = n.get();
|
||||
pointer_plus_2_bits<T*>::set_pointer(raw_n, p.get());
|
||||
n = raw_n;
|
||||
}
|
||||
|
||||
static std::size_t get_bits(const pointer &n)
|
||||
{ return pointer_plus_2_bits<T*>::get_bits(n.get()); }
|
||||
|
||||
static void set_bits(pointer &n, std::size_t c)
|
||||
{
|
||||
T *raw_n = n.get();
|
||||
pointer_plus_2_bits<T*>::set_bits(raw_n, c);
|
||||
n = raw_n;
|
||||
}
|
||||
};
|
||||
|
||||
} //namespace intrusive
|
||||
} //namespace boost{
|
||||
|
||||
#endif //#ifndef BOOST_INTRUSIVE_SMART_PTR_HPP
|
||||
Reference in new issue
Block a user