sharedptr.h

Go to the documentation of this file.

#ifndef ION_BASE_SHAREDPTR_H_
#define ION_BASE_SHAREDPTR_H_

#include <algorithm>

#include "base/macros.h"
#include "ion/base/logging.h"
#include "ion/base/shareable.h"

namespace ion {
namespace base {

template <typename T> class SharedPtr {
 public:
  SharedPtr() : ptr_(NULL), shr_(NULL) {}

  explicit SharedPtr(T* shared) : ptr_(shared), shr_(shared) {
    AddReference();
  }

  template <typename U> SharedPtr(const SharedPtr<U>& p)
      : ptr_(p.Get()), shr_(p.Get()) {
    AddReference();
  }

  SharedPtr(const SharedPtr<T>& p) : ptr_(p.Get()), shr_(p.shr_) {
    AddReference();
  }

  ~SharedPtr() {
    RemoveReference();
    ptr_ = NULL;
    shr_ = NULL;
  }

  T* Get() const { return ptr_; }

  void Reset(T* new_shared) {
    if (new_shared != ptr_) {
      RemoveReference();
      ptr_ = new_shared;
      shr_ = new_shared;
      AddReference();
    }
  }

  void Reset() {
    RemoveReference();
    ptr_ = NULL;
    shr_ = NULL;
  }

  SharedPtr<T>& operator=(T* new_shared) {
    Reset(new_shared);
    return *this;
  }

  template <typename U> SharedPtr<T>& operator=(U* new_shared) {
    Reset(static_cast<T*>(new_shared));
    return *this;
  }

  SharedPtr<T>& operator=(const SharedPtr<T>& p) {
    if (p.Get() != ptr_) {
      RemoveReference();
      ptr_ = p.Get();
      shr_ = p.shr_;
      AddReference();
    }
    return *this;
  }

  template <typename U> SharedPtr<T>& operator=(const SharedPtr<U>& p) {
    Reset(p.Get());
    return *this;
  }

  T* operator->() const {
    DCHECK(ptr_);
    return ptr_;
  }

  T& operator*() const {
    DCHECK(ptr_);
    return *ptr_;
  }

  bool operator==(const SharedPtr<T>& p) const {
    return p.ptr_ == ptr_;
  }

  bool operator!=(const SharedPtr<T>& p) const {
    return p.ptr_ != ptr_;
  }

  void swap(SharedPtr<T>& p) {
    std::swap(ptr_, p.ptr_);
    std::swap(shr_, p.shr_);
  }

 private:
  void AddReference() {
    if (shr_)
      shr_->IncrementRefCount();
  }

  void RemoveReference() {
    if (shr_)
      shr_->DecrementRefCount();
  }

  T* ptr_;
  const Shareable* shr_;
};

template <typename To, typename From>
SharedPtr<To> DynamicPtrCast(const SharedPtr<From>& orig) {
  return SharedPtr<To>(dynamic_cast<To*>(orig.Get()));
}


}  // namespace base
}  // namespace ion

#endif  // ION_BASE_SHAREDPTR_H_