shared_ptr.h

Go to the documentation of this file.

#ifndef CVMFS_UTIL_SHARED_PTR_H_
#define CVMFS_UTIL_SHARED_PTR_H_

#include <cstdlib>

#include "util/atomic.h"

#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif  // CVMFS_NAMESPACE_GUARD

template <typename T>
class SharedPtr {
 public:
  typedef T element_type;

  SharedPtr() {  // never throws
    value_ = NULL;
    count_ = NULL;
  }

  template <class Y>
  explicit SharedPtr(Y* p) {
    value_ = static_cast<element_type*>(p);
    count_ = new atomic_int64;
    atomic_write64(count_, 1);
  }

  ~SharedPtr() {  // never throws
    if (count_) {
      atomic_dec64(count_);
      if (atomic_read64(count_) == 0) {
        delete value_;
        delete count_;
      }
    }
  }

  SharedPtr(SharedPtr const& r)
      : value_(r.value_), count_(r.count_) {  // never throws
    if (count_) {
      atomic_inc64(count_);
    }
  }

  template <class Y>
  explicit SharedPtr(SharedPtr<Y> const& r)
      : value_(r.value_), count_(r.count_) {  // never throws
    if (count_) {
      atomic_inc64(count_);
    }
  }

  SharedPtr& operator=(SharedPtr const& r) {  // never throws
    if (this == &r)
      return *this;

    Reset();
    value_ = r.value_;
    count_ = r.count_;
    if (count_) {
      atomic_inc64(count_);
    }
    return *this;
  }

  template <class Y>
  SharedPtr& operator=(SharedPtr<Y> const& r) {  // never throws
    Reset();
    value_ = r.Get();
    count_ = r.GetCountPtr();
    if (count_) {
      atomic_inc64(count_);
    }
    return *this;
  }

  void Reset() {  // never throws
    if (count_) {
      atomic_dec64(count_);
      if (atomic_read64(count_) == 0) {
        delete value_;
        delete count_;
      }
      value_ = NULL;
      count_ = NULL;
    }
  }

  template <class Y>
  void Reset(Y* p) {
    Reset();
    value_ = static_cast<element_type*>(p);
    count_ = new atomic_int64;
    atomic_write64(count_, 1);
  }

  T& operator*() const {  // never throws
    return *value_;
  }

  T* operator->() const {  // never throws
    return value_;
  }

  element_type* Get() const {  // never throws
    return value_;
  }

  atomic_int64* GetCountPtr() const {
    return count_;
  }

  bool Unique() const {  // never throws
    return count_ && (atomic_read64(count_) == 1);
  }

  int64_t UseCount() const {  // never throws
    return count_ ? atomic_read64(count_) : -1;
  }

 private:
  element_type* value_;
  atomic_int64* count_;
};

template <class T, class U>
bool operator==(SharedPtr<T> const& a,
                SharedPtr<U> const& b) {  // never throws
  return a.value_ == b.value_;
}

template <class T, class U>
bool operator!=(SharedPtr<T> const& a,
                SharedPtr<U> const& b) {  // never throws
  return a.value_ != b.value_;
}

template <class T, class U>
bool operator<(SharedPtr<T> const& a, SharedPtr<U> const& b) {  // never throws
  return a.value_ < b.value_;
}

template <class T>
typename SharedPtr<T>::element_type* GetPointer(
    SharedPtr<T> const& p) {  // never throws
  return p.value_;
}

template <class T, class U>
SharedPtr<T> StaticPointerCast(SharedPtr<U> const& r) {  // never throws
  return SharedPtr<T>(static_cast<T*>(r.value_));
}

template <class T, class U>
SharedPtr<T> ConstPointerCast(SharedPtr<U> const& r) {  // never throws
  return SharedPtr<T>(const_cast<T*>(r.value_));
}

template <class T, class U>
SharedPtr<T> DynamicPointerCast(SharedPtr<U> const& r) {  // never throws
  return SharedPtr<T>(dynamic_cast<T*>(r.value_));
}

template <class T, class U>
SharedPtr<T> ReinterpretPointerCast(SharedPtr<U> const& r) {  // never throws
  return SharedPtr<T>(reinterpret_cast<T*>(r.value_));
}

#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_UTIL_SHARED_PTR_H_