shared_ptr.h

Go to the documentation of this file.

//
// Copyright (c) 2006-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Wed Aug 16 14:39:14 2006
// commit: $Id: shared_ptr.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/rutz/shared_ptr.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://www.klab.caltech.edu/rjpeters/groovx/]
//
// GroovX is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// GroovX is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_RUTZ_SHARED_PTR_H_UTC20070412044942_DEFINED
#define GROOVX_RUTZ_SHARED_PTR_H_UTC20070412044942_DEFINED

#include "rutz/atomic.h"
#include "rutz/traits.h"

namespace rutz
{
  namespace shared_ptr_aux
  {
    typedef void (ptr_check_function)(const void*);


    ptr_check_function* set_check_function(ptr_check_function* func);

    void check_ptr(const void* p);
  }

  template <class T> class shared_ptr;
}


template<class T>
class rutz::shared_ptr
{
public:

  explicit inline shared_ptr(T* p =0);

  inline shared_ptr(const shared_ptr& r) throw();


  inline ~shared_ptr();

  inline shared_ptr& operator=(const shared_ptr& r);


  template<class TT>
  inline shared_ptr(const shared_ptr<TT>& r) throw();


  template<class TT>
  inline shared_ptr& operator=(const shared_ptr<TT>& r);


  template <class TT>
  inline shared_ptr& dyn_cast_from(const shared_ptr<TT>& r);

  template <class TT>
  inline shared_ptr& dynCastFrom(const shared_ptr<TT>& r)
  { return this->dyn_cast_from(r); }

  inline void reset(T* p=0);

  inline T& operator*() const throw() { return *px; }

  inline T* operator->() const throw() { return px; }

  inline T* get() const throw() { return px; }

  bool is_valid() const throw() { return px != 0; }

  bool is_invalid() const throw() { return px == 0; }

  inline int use_count() const throw() { return pn->atomic_get(); }

  inline bool unique() const throw() { return use_count() == 1; }

  inline void swap(shared_ptr<T>& that) throw();

private:
  T*                   px; // pointee
  rutz::atomic_int_t*  pn; // reference count with atomic incr/decr operations

  template<class TT> friend class shared_ptr;
};



// ######################################################################
// ######################################################################
// ##### INLINED FREE FUNCTIONS:
// ######################################################################
// ######################################################################

namespace rutz
{

  template<class T, class U>
  inline bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b)
  {
    return a.get() == b.get();
  }

  template<class T, class U>
  inline bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b)
  {
    return a.get() != b.get();
  }

  template <class T>
  inline shared_ptr<T> make_shared(T* t) { return shared_ptr<T>(t); }

  template <class Dst, class Src>
  inline shared_ptr<Dst> dyn_cast(const shared_ptr<Src>& src)
  {
    shared_ptr<Dst> dst;
    dst.dyn_cast_from(src);
    return dst;
  }

  template <class Dst, class Src>
  inline void dyn_cast_to_from(shared_ptr<Dst>& dst, const shared_ptr<Src>& src)
  {
    dst.dyn_cast_from(src);
  }

  template <class Dst, class Src>
  inline shared_ptr<Dst> dynCast(const shared_ptr<Src>& src)
  { return dyn_cast<Dst,Src>(src); }

  template <class Dst, class Src>
  inline void dynCastToFrom(shared_ptr<Dst>& dst, const shared_ptr<Src>& src)
  { dyn_cast_to_from<Dst,Src>(dst, src); }

}

// ######################################################################
// ######################################################################
// ##### INLINED MEMBER FUNCTIONS:
// ######################################################################
// ######################################################################

// ######################################################################
template <class T> inline
rutz::shared_ptr<T>::shared_ptr(T* p) :
  px(p), pn(0)
{
#if defined(GVX_MEM_DEBUG)
  // Only call check_ptr() if GVX_MEM_DEBUG has been defined, because
  // this is a relatively expensive operation and can bog things down
  // if many shared_ptr objects are being created/destroyed in an
  // inner loop.

  // We use full_object_cast() to get the address of the beginning of
  // the full object. That is slightly non-trivial, because, depending
  // on whether or not T is a polymorphic type, we might either have
  // to use a static_cast<void*> or a dynamic_cast<void*> to get the
  // full object address. That is all encapsulated by
  // rutz::full_object_cast().
  rutz::shared_ptr_aux::check_ptr(rutz::full_object_cast(p));
#endif

  // prevent leak if new throws:
  try { pn = new rutz::atomic_int_t; pn->atomic_set(1); }
  catch (...) { delete p; throw; }
}

// ######################################################################
template <class T> inline
rutz::shared_ptr<T>::shared_ptr(const shared_ptr<T>& r) throw() :
  px(r.px), pn(r.pn)
{
  pn->atomic_incr();
}

// ######################################################################
template <class T> inline
rutz::shared_ptr<T>::~shared_ptr()
{
  if (pn->atomic_decr_test_zero())
    {
      delete px; px = 0;
      delete pn; pn = 0;
    }
}

// ######################################################################
template <class T> inline
rutz::shared_ptr<T>&
rutz::shared_ptr<T>::operator=(const rutz::shared_ptr<T>& r)
{
  shared_ptr(r).swap(*this);
  return *this;
}

// ######################################################################
template <class T>
template<class TT> inline
rutz::shared_ptr<T>::shared_ptr(const rutz::shared_ptr<TT>& r) throw() :
  px(r.px), pn(r.pn)
{
  pn->atomic_incr();
}

// ######################################################################
template <class T>
template<class TT> inline
rutz::shared_ptr<T>&
rutz::shared_ptr<T>::operator=(const rutz::shared_ptr<TT>& r)
{
  shared_ptr(r).swap(*this);
  return *this;
}

// ######################################################################
template <class T>
template<class TT> inline
rutz::shared_ptr<T>&
rutz::shared_ptr<T>::dyn_cast_from(const rutz::shared_ptr<TT>& r)
{
  // if we are already initialized to something (and we always are),
  // simulate a destroy:
  if (pn->atomic_decr_test_zero())
    {
      delete px; px = 0;
      delete pn; pn = 0;
    }

  // first do the dynamic_cast so we can test whether it succeeded:
  T* const new_px = dynamic_cast<T*>(r.px);

  if (new_px == 0 && r.px != 0)
    {
      // the cast failed, so we set up a new ref count (NOTE: we DON'T
      // want to share the ref count in this case, because the
      // original shared_ptr and this shared_ptr will be pointing to
      // DIFFERENT objects -- the original has a valid pointer but we
      // have a null pointer):
      pn = new rutz::atomic_int_t; pn->atomic_set(1);
    }
  else
    {
      // share the ref count without increasing it:
      pn = r.pn;

      // increase it to account for our existence:
      pn->atomic_incr();

      // share ownership of the original pointee:
      px = new_px;
    }
  return *this;
}

// ######################################################################
template <class T> inline
void rutz::shared_ptr<T>::reset(T* p)
{
  shared_ptr(p).swap(*this);
}

// ######################################################################
template <class T> inline
void rutz::shared_ptr<T>::swap(shared_ptr<T>& that) throw()
{
  T* that_px = that.px; that.px = this->px; this->px = that_px;
  rutz::atomic_int_t* that_pn = that.pn; that.pn = this->pn; this->pn = that_pn;
}

// ######################################################################
/* So things look consistent in everyone's emacs... */
/* Local Variables: */
/* indent-tabs-mode: nil */
/* End: */

static const char __attribute__((used)) vcid_groovx_rutz_shared_ptr_h_utc20070412044942[] = "$Id: shared_ptr.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_RUTZ_SHARED_PTR_H_UTC20070412044942DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:41 2008 by Doxygen version 1.5.5.