fei_SharedPtr.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#ifndef _fei_SharedPtr_hpp_
#define _fei_SharedPtr_hpp_

#include <fei_macros.hpp>
//
//fei::SharedPtr is a copy of the Sierra system's SharedPtr class, which
//was added by Kevin Copps. This class is a close copy of the boost shared_ptr.
//
//NOTE: In this copy, I've removed the member function 'swap', and the 
//std::less specialization.
//
//boost::shared_ptr now allows a second template parameter which specifies
//a deleter object. Instead of adopting that, I'm taking a lazy approach and
//simply adding a default bool argument to a constructor which specifies 
//whether the SharedPtr should delete the pointer or not.
//

// #ifdef SIERRA_NO_MEMBER_TEMPLATES
// #define FEI_NO_MEMBER_TEMPLATES
// #endif

namespace fei {

template<typename T> class SharedPtr { 
 
  public: 
 
    typedef T element_type; 
 
    explicit SharedPtr(T* p) 
      : pointer(p)
      {
  try { // prevent leak if new throws 
    count = new long(1); 
  } catch (...) {
    delete p;
    throw;
  }
      }
 
    SharedPtr(void) 
      : pointer(0) {
        count = new long(1); 
    } 


   ~SharedPtr() { dispose(); } 
 
#if !defined( FEI_NO_MEMBER_TEMPLATES ) 

  template<typename Y> 
     SharedPtr(const SharedPtr<Y>& x)
    : pointer(x.pointer)
    { 
      ++*(count = x.count);
    } 
 
  template<typename Y> 
    SharedPtr& operator=(const SharedPtr<Y>& x) {  
        share(x.pointer,x.count);
        return *this; 
    } 
#endif // FEI_NO_MEMBER_TEMPLATES 
 
  SharedPtr(const SharedPtr& x) 
    : pointer(x.pointer)
    {
      ++*(count = x.count);
    }
 
  SharedPtr& operator=(const SharedPtr& x) { 
    share(x.pointer, x.count);
    return *this; 
  } 
 
  void reset(T* p=0) {
    if ( pointer == p ) return;
    if (--*count == 0) { 
      delete pointer;
    } 
    else { // allocate new reference counter
      try { 
  count = new long; 
      } 
      catch (...) { 
  ++*count; 
  delete p; 
  throw; 
      }
    }
    *count = 1;
    pointer = p; 
  } 
 
  T& operator*() const          { return *pointer; } 
 
  T* operator->() const         { return pointer; } 
 
  T* get() const                { return pointer; } 
 
  long use_count() const        { return *count; } 
 
  bool unique() const           { return *count == 1; } 
 
  void share(T* xpointer, long* xcount) { 
    if (count != xcount) { 
      ++*xcount; 
      dispose(); 
      pointer = xpointer; 
      count = xcount; 
    } 
  } 
 
  void dispose() { 
    if (--*count == 0) { 
      delete pointer; 
      delete count; 
    } 
  } 
 
  // Making all members public allows member templates 
  // to work in the absence of member template friends. 
#if defined( FEI_NO_MEMBER_TEMPLATES ) || !defined( FEI_NO_MEMBER_TEMPLATES ) 
   private: 
#endif 
 
   T*     pointer; // contained pointer 
   long*  count;   // ptr to reference counter

#if !defined( FEI_NO_MEMBER_TEMPLATES ) && !defined( FEI_NO_MEMBER_TEMPLATES ) 
   template<typename Y> friend class SharedPtr; 
#endif 
 
};  // end class SharedPtr 
 
template<typename T, typename U> 
  inline bool operator==(const SharedPtr<T>& a, const SharedPtr<U>& b) 
    { return a.get() == b.get(); } 
 
template<typename T, typename U> 
  inline bool operator!=(const SharedPtr<T>& a, const SharedPtr<U>& b) 
    { return a.get() != b.get(); } 

} // namespace fei

#endif // _fei_SharedPtr_hpp_