SharedPtrControlBlock

template <typename T> class shared_ptr;
template <typename T> class weak_ptr;
 
// This class is an internal implementation detail for shared_ptr.
class SharedPtrControlBlock {
  template <typename T> friend class shared_ptr;
  template <typename T> friend class weak_ptr;
 private:
  SharedPtrControlBlock() : refcount_(1), weak_count_(1) { }
  int refcount_;
  int weak_count_;
};
 
// NOTE: It is strongly encouraged to use scoped_ptr if you could.
//       shared_ptr should be only used at the cases that
//       there is no clear owner for the object, anyone reference the object
//       may need take care if the object should be deleted.
// NOTE: Don‘t use this class to replace boost::shared_ptr when working with
//       thrift.
template <typename T>
class shared_ptr {
  template <typename U> friend class weak_ptr;
 public:
  typedef T element_type;
 
  explicit shared_ptr(T* ptr = NULL)
      : ptr_(ptr),
        control_block_(ptr != NULL ? new SharedPtrControlBlock : NULL) {
  }
 
  // Copy constructor: makes this object a copy of ptr
  template <typename U>
  shared_ptr(const shared_ptr<U>& ptr)  // NOLINT
      : ptr_(NULL),
        control_block_(NULL) {
    Initialize(ptr);
  }
  // Need non-templated version to prevent the compiler-generated default
  shared_ptr(const shared_ptr<T>& ptr)  // NOLINT
      : ptr_(NULL),
        control_block_(NULL) {
    Initialize(ptr);
  }
 
  // Assignment operator. Replaces the existing shared_ptr with ptr.
  template <typename U>
  shared_ptr<T>& operator=(const shared_ptr<U>& ptr) {
    if (ptr_ != ptr.ptr_) {
      shared_ptr<T> me(ptr);   // will hold our previous state to be destroyed.
      swap(me);
    }
    return *this;
  }
 
  // Need non-templated version to prevent the compiler-generated default
  shared_ptr<T>& operator=(const shared_ptr<T>& ptr) {
    if (ptr_ != ptr.ptr_) {
      shared_ptr<T> me(ptr);   // will hold our previous state to be destroyed.
      swap(me);
    }
    return *this;
  }
 
  ~shared_ptr() {
    if (ptr_ != NULL) {
      if (AtomicDecrement(&control_block_->refcount_) == 0) {
        delete ptr_;
 
        // weak_count_ is defined as the number of weak_ptrs that observe
        // ptr_, plus 1 if refcount_ is nonzero.
        if (AtomicDecrement(&control_block_->weak_count_) == 0) {
          delete control_block_;
        }
      }
    }
  }
 
  // Replaces underlying raw pointer with the one passed in.  The reference
  // count is set to one (or zero if the pointer is NULL) for the pointer
  // being passed in and decremented for the one being replaced.
  void reset(T* p = NULL) {
    if (p != ptr_) {
      shared_ptr<T> tmp(p);
      tmp.swap(*this);
    }
  }
 
  // Exchanges the contents of this with the contents of r.  This function
  // supports more efficient swapping since it eliminates the need for a
  // temporary shared_ptr object.
  void swap(shared_ptr<T>& r) {
    std::swap(ptr_, r.ptr_);
    std::swap(control_block_, r.control_block_);
  }
 
  // The following function is useful for gaining access to the underlying
  // pointer when a shared_ptr remains in scope so the reference-count is
  // known to be > 0 (e.g. for parameter passing).
  T* get() const {
    return ptr_;
  }
 
  T& operator*() const {
    return *ptr_;
  }
 
  T* operator->() const {
    return ptr_;
  }
 
  int use_count() const {
    return control_block_ ? control_block_->refcount_ : 1;
  }
 
  bool unique() const {
    return use_count() == 1;
  }
 
 private:
  // If r is non-empty, initialize *this to share ownership with r,
  // increasing the underlying reference count.
  // If r is empty, *this remains empty.
  // Requires: this is empty, namely this->ptr_ == NULL.
  template <typename U>
  void Initialize(const shared_ptr<U>& r) {
    if (r.control_block_ != NULL) {
      AtomicIncrement(&r.control_block_->refcount_);
 
      ptr_ = r.ptr_;
      control_block_ = r.control_block_;
    }
  }
 
  T* ptr_;
  SharedPtrControlBlock* control_block_;
 
  template <typename U>
  friend class shared_ptr;
};
 
// Matches the interface of std::swap as an aid to generic programming.
template <typename T> void swap(shared_ptr<T>& r, shared_ptr<T>& s) {
  r.swap(s);
}
 
// Weak ptrs:
//   The weak_ptr auxiliary class is used to break ownership cycles. A weak_ptr
//   points to an object that‘s owned by a shared_ptr, but the weak_ptr is an
//   observer, not an owner. When the last shared_ptr that points to the object
//   disappear, the weak_ptr expires, at which point the expired() member
//   function will return true.
//   You can‘t directly get a raw pointer from weak_ptr, to access a weak_ptr‘s
//   pointed-to object, use lock() to obtain a temporary shared_ptr.
//   See the draft C++ standard (as of October 2007 the latest draft is N2461)
//   for the detailed specification.
template <typename T>
class weak_ptr {
  template <typename U> friend class weak_ptr;
 public:
  typedef T element_type;
 
  // Create an empty (i.e. already expired) weak_ptr.
  weak_ptr() : ptr_(NULL), control_block_(NULL) { }
 
  // Create a weak_ptr that observes the same object that ptr points
  // to.  Note that there is no race condition here: we know that the
  // control block can‘t disappear while we‘re looking at it because
  // it is owned by at least one shared_ptr, ptr.
  template <typename U> weak_ptr(const shared_ptr<U>& ptr) {
    CopyFrom(ptr.ptr_, ptr.control_block_);
  }
 
  // Copy a weak_ptr. The object it points to might disappear, but we
  // don‘t care: we‘re only working with the control block, and it can‘t
  // disappear while we‘re looking at because it‘s owned by at least one
  // weak_ptr, ptr.
  template <typename U> weak_ptr(const weak_ptr<U>& ptr) {
    CopyFrom(ptr.ptr_, ptr.control_block_);
  }
 
  // Need non-templated version to prevent default copy constructor
  weak_ptr(const weak_ptr& ptr) {
    CopyFrom(ptr.ptr_, ptr.control_block_);
  }
 
  // Destroy the weak_ptr. If no shared_ptr owns the control block, and if
  // we are the last weak_ptr to own it, then it can be deleted. Note that
  // weak_count_ is defined as the number of weak_ptrs sharing this control
  // block, plus 1 if there are any shared_ptrs. We therefore know that it‘s
  // safe to delete the control block when weak_count_ reaches 0, without
  // having to perform any additional tests.
  ~weak_ptr() {
    if (control_block_ != NULL &&
        (AtomicDecrement(&control_block_->weak_count_) == 0)) {
      delete control_block_;
    }
  }
 
  weak_ptr& operator=(const weak_ptr& ptr) {
    if (&ptr != this) {
      weak_ptr tmp(ptr);
      tmp.swap(*this);
    }
    return *this;
  }
  template <typename U> weak_ptr& operator=(const weak_ptr<U>& ptr) {
    weak_ptr tmp(ptr);
    tmp.swap(*this);
    return *this;
  }
  template <typename U> weak_ptr& operator=(const shared_ptr<U>& ptr) {
    weak_ptr tmp(ptr);
    tmp.swap(*this);
    return *this;
  }
 
  void swap(weak_ptr& ptr) {
    swap_weak_ptr(ptr_, ptr.ptr_);
    swap_weak_ptr(control_block_, ptr.control_block_);
  }
 
  void reset() {
    weak_ptr tmp;
    tmp.swap(*this);
  }
 
  // Return the number of shared_ptrs that own the object we are observing.
  // Note that this number can be 0 (if this pointer has expired).
  int use_count() const {
    return control_block_ != NULL ? control_block_->refcount_ : 0;
  }
 
  bool expired() const { return use_count() == 0; }
 
 private:
  void CopyFrom(T* ptr, SharedPtrControlBlock* control_block) {
    ptr_ = ptr;
    control_block_ = control_block;
    if (control_block_ != NULL)
      AtomicIncrement(&control_block_->weak_count_);
  }
 
 private:
  element_type* ptr_;
  SharedPtrControlBlock* control_block_;
};
 
template <typename T> void swap_weak_ptr(weak_ptr<T>& r, weak_ptr<T>& s) {
  r.swap(s);
}