smart_ptr.hpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

//////////////////////////////////////////////////////////////////////////////
//
// (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_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.
   explicit 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 Alignment>
struct max_pointer_plus_bits<smart_ptr<void>, Alignment>
{
   static const std::size_t value = max_pointer_plus_bits<void*, Alignment>::value;
};

template<class T, std::size_t NumBits>
struct pointer_plus_bits<smart_ptr<T>, NumBits>
{
   typedef smart_ptr<T>         pointer;

   static pointer get_pointer(const pointer &n)
   {  return pointer_plus_bits<T*, NumBits>::get_pointer(n.get());  }

   static void set_pointer(pointer &n, pointer p)
   {
      T *raw_n = n.get();
      pointer_plus_bits<T*, NumBits>::set_pointer(raw_n, p.get());
      n = raw_n;
   }

   static std::size_t get_bits(const pointer &n)
   {  return pointer_plus_bits<T*, NumBits>::get_bits(n.get());  }

   static void set_bits(pointer &n, std::size_t c)
   {
      T *raw_n = n.get();
      pointer_plus_bits<T*, NumBits>::set_bits(raw_n, c);
      n = raw_n;
   }
};

}  //namespace intrusive
}  //namespace boost{

#endif //#ifndef BOOST_INTRUSIVE_SMART_PTR_HPP