shared_ptr.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// $Id: smartpointer.hh 5504 2009-04-08 13:35:31Z christi $
 
#ifndef DUNE_SHARED_PTR_HH
#define DUNE_SHARED_PTR_HH
 
#if defined SHARED_PTR_HEADER
# include SHARED_PTR_HEADER
#endif
#if defined HAVE_BOOST_SHARED_PTR_HPP
#if defined HAVE_BOOST_MAKE_SHARED_HPP
# include <boost/make_shared.hpp>
#endif
#endif
 
#include <dune/common/nullptr.hh>
#include <dune/common/typetraits.hh>
namespace Dune
{
  // A shared_ptr implementation has been found if SHARED_PTR_NAMESPACE is set at all
#ifdef SHARED_PTR_NAMESPACE
  using SHARED_PTR_NAMESPACE :: shared_ptr;
#else
 
  class SharedCount
  {
    template<class T1>
    friend class shared_ptr;
  protected:
    int count_;
    SharedCount() : count_(1) {}
    SharedCount(const SharedCount& rep)
      : count_(rep.count_) {}
 
    virtual ~SharedCount() {};
 
  };
  template<class T>
  class shared_ptr
  {
    template<class T1> friend class shared_ptr;
 
  public:
    typedef T element_type;
 
    inline shared_ptr();
 
    inline shared_ptr(nullptr_t null);
 
    template<class T1>
    inline shared_ptr(T1 * pointer);
 
 
    template<class T1, class Deleter>
    inline shared_ptr(T1 * pointer, Deleter deleter);
 
    template<class T1>
    inline shared_ptr(const shared_ptr<T1>& pointer);
 
    inline shared_ptr(const shared_ptr& pointer);
 
    inline ~shared_ptr();
 
    template<class T1>
    inline shared_ptr& operator=(const shared_ptr<T1>& pointer);
 
    inline shared_ptr& operator=(const shared_ptr& pointer);
 
    inline element_type& operator*();
 
    inline element_type* operator->();
 
    inline const element_type& operator*() const;
 
    inline const element_type* operator->() const;
 
    element_type* get() const {
      return rep_;
    }
 
    operator bool() const {
      return count_ != 0 && rep_ != 0;
    }
 
    inline void swap(shared_ptr& other);
 
    inline void reset();
 
    template<class T1>
    inline void reset(T1* pointer);
 
    //** \brief Same as shared_ptr(pointer,deleter).swap(*this)
    template<class T1, class Deleter>
    inline void reset(T1* pointer, Deleter deleter);
 
    int use_count() const;
 
  private:
    template<class T1>
    inline shared_ptr& assign(const shared_ptr<T1>& pointer);
    template<class Deleter>
    class SharedCountImpl :
      public SharedCount
    {
      template<class T1>
      friend class shared_ptr;
      SharedCountImpl(T* elem,const Deleter& deleter) :
        SharedCount(),
        deleter_(deleter),
        rep_(elem)
      {}
      SharedCountImpl(const SharedCountImpl& rep)
        : SharedCount(rep), deleter_(rep.deleter_), rep_(rep.rep_) {}
      ~SharedCountImpl()
      { deleter_(rep_); }
 
      // store a copy of the deleter
      Deleter deleter_;
      T* rep_;
    };
 
    struct DefaultDeleter
    {
      void operator() (element_type* p) const
      { delete p; }
    };
 
 
    SharedCount *count_;
    T *rep_;
 
    // Needed for the implicit conversion to "bool"
    typedef T* *__unspecified_bool_type;
 
  public:
    operator __unspecified_bool_type() const     // never throws
    {
      return rep_ == 0 ? 0 : &shared_ptr::rep_;
    }
 
  };
 
  template<class T>
  template<class T1>
  inline shared_ptr<T>::shared_ptr(T1 * p)
  {
    rep_ = p;
    count_ = new SharedCountImpl<DefaultDeleter>(p, DefaultDeleter());
  }
 
  template<class T>
  inline shared_ptr<T>::shared_ptr(nullptr_t)
  {
    rep_   = 0;
    count_ = 0;
  }
 
  template<class T>
  template<class T1, class Deleter>
  inline shared_ptr<T>::shared_ptr(T1 * p, Deleter deleter)
  {
    rep_ = p;
    count_ = new SharedCountImpl<Deleter>(p, deleter);
  }
 
  template<class T>
  inline shared_ptr<T>::shared_ptr()
  {
    rep_ = 0;
    count_=0;
  }
 
  template<class T>
  template<class T1>
  inline shared_ptr<T>::shared_ptr(const shared_ptr<T1>& other)
    : count_(other.count_), rep_(other.rep_)
  {
    if (rep_)
      ++(count_->count_);
  }
 
  template<class T>
  inline shared_ptr<T>::shared_ptr(const shared_ptr& other)
    : count_(other.count_), rep_(other.rep_)
  {
    if (rep_)
      ++(count_->count_);
  }
 
  template<class T>
  template<class T1>
  inline shared_ptr<T>& shared_ptr<T>::operator=(const shared_ptr<T1>& other)
  {
    return assign(other);
  }
 
  template<class T>
  inline shared_ptr<T>& shared_ptr<T>::operator=(const shared_ptr& other)
  {
    return assign(other);
  }
 
  template<class T>
  template<class T1>
  inline shared_ptr<T>& shared_ptr<T>::assign(const shared_ptr<T1>& other)
  {
    if (other.count_)
      (other.count_->count_)++;
 
    if(rep_!=0 && --(count_->count_)<=0) {
      delete count_;
    }
 
    rep_ = other.rep_;
    count_ = other.count_;
    return *this;
  }
 
  template<class T>
  inline shared_ptr<T>::~shared_ptr()
  {
    if(rep_!=0 && --(count_->count_)==0) {
      delete count_;
      rep_=0;
    }
  }
 
  template<class T>
  inline T& shared_ptr<T>::operator*()
  {
    return *(rep_);
  }
 
  template<class T>
  inline T *shared_ptr<T>::operator->()
  {
    return rep_;
  }
 
  template<class T>
  inline const T& shared_ptr<T>::operator*() const
  {
    return *(rep_);
  }
 
  template<class T>
  inline const T *shared_ptr<T>::operator->() const
  {
    return rep_;
  }
 
  template<class T>
  inline int shared_ptr<T>::use_count() const
  {
    return count_->count_;
  }
 
  template<class T>
  inline void shared_ptr<T>::swap(shared_ptr<T>& other)
  {
    SharedCount* dummy = count_;
    count_=other.count_;
    other.count_ = dummy;
    T* tdummy=rep_;
    rep_ = other.rep_;
    other.rep_ = tdummy;
  }
 
  template<class T>
  inline void shared_ptr<T>::reset()
  {
    shared_ptr<T>().swap(*this);
  }
 
  template<class T>
  template<class T1>
  inline void shared_ptr<T>::reset(T1* pointer)
  {
    shared_ptr<T>(pointer).swap(*this);
  }
 
  template<class T>
  template<class T1, class Deleter>
  inline void shared_ptr<T>::reset(T1* pointer, Deleter deleter)
  {
    shared_ptr<T>(pointer, deleter).swap(*this);
  }
 
#endif  // #ifdef SHARED_PTR_NAMESPACE
 
 
  // C++0x and Boost have a make_shared implementation, TR1 does not.
  // Unfortunately, TR1 gets picked over Boost if present.
  // Moreover, boost::make_shared() only exists for (remotely) recent versions of Boost.
#if HAVE_MAKE_SHARED
#ifdef SHARED_PTR_NAMESPACE
  using SHARED_PTR_NAMESPACE :: make_shared;
#endif
#else
 
  template<typename T>
  shared_ptr<T> make_shared()
  {
    return shared_ptr<T>(new T());
  }
 
  template<typename T, typename Arg1>
  shared_ptr<T> make_shared(const Arg1& arg1)
  {
    return shared_ptr<T>(new T(arg1));
  }
 
  template<typename T, typename Arg1, typename Arg2>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2)
  {
    return shared_ptr<T>(new T(arg1,arg2));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
                            const Arg5& arg5)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4,arg5));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5, typename Arg6>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
                            const Arg5& arg5, const Arg6& arg6)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4,arg5,arg6));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5, typename Arg6, typename Arg7>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
                            const Arg5& arg5, const Arg6& arg6, const Arg7& arg7)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4,arg5,arg6,arg7));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5, typename Arg6, typename Arg7, typename Arg8>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
                            const Arg5& arg5, const Arg6& arg6, const Arg7& arg7, const Arg8& arg8)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8));
  }
 
  template<typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename Arg9>
  shared_ptr<T> make_shared(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
                            const Arg5& arg5, const Arg6& arg6, const Arg7& arg7, const Arg8& arg8,
                            const Arg9& arg9)
  {
    return shared_ptr<T>(new T(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9));
  }
 
#endif // custom make_shared
 
  template<class T>
  struct null_deleter
  {
    void operator() (T*) const {}
  };
 
  template<typename T>
  inline shared_ptr<T> stackobject_to_shared_ptr(T & t)
  {
    return shared_ptr<T>(&t, null_deleter<T>());
  }
 
  template<typename T, typename T2>
  inline shared_ptr<T2> stackobject_to_shared_ptr(T & t)
  {
    return shared_ptr<T2>(dynamic_cast<T2*>(&t), null_deleter<T2>());
  }
 
}
#endif