weakreferent.h

Go to the documentation of this file.

#ifndef ION_BASE_WEAKREFERENT_H_
#define ION_BASE_WEAKREFERENT_H_

#include <algorithm>

#include "base/macros.h"
#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/referent.h"
#include "ion/base/sharedptr.h"
#include "ion/port/atomic.h"

namespace ion {
namespace base {

class WeakReferent : public Referent {
 protected:
  WeakReferent() : proxy_(NULL) {}

  ~WeakReferent() override {
    DCHECK(proxy_.load() == NULL);
  }

 private:
  class Proxy : public Allocatable, public Shareable {
   public:
    explicit Proxy(WeakReferent* ptr) : ptr_(ptr) { DCHECK(ptr_); }

    WeakReferent* Get() const {
      DCHECK(mutex_.IsLocked());
      return ptr_;
    }

    WeakReferent* GetUnsynchronized() const {
      return ptr_;
    }

    void SetOrphaned() {
      DCHECK(mutex_.IsLocked());
      ptr_ = NULL;
    }

    SpinMutex* GetMutex() const { return &mutex_; }

   private:
    WeakReferent* ptr_;

    mutable SpinMutex mutex_;
  };

  Proxy* GetProxy() const {
    Proxy* proxy = proxy_.load(std::memory_order_acquire);
    if (proxy) {
      return proxy;
    }

    proxy = new(GetAllocator()) Proxy(const_cast<WeakReferent*>(this));
    proxy->IncrementRefCount();
    Proxy* null = NULL;
    if (proxy_.compare_exchange_strong(null, proxy)) {
      DCHECK(proxy == proxy_);
      return proxy;
    } else {
#if !defined(ION_COVERAGE)  // COV_NF_START
      proxy->DecrementRefCount();
      proxy = proxy_;
      DCHECK(proxy_.load() != NULL) << "proxy should not be NULL after CAS";
      return proxy;
#endif  // COV_NF_END
    }
  }

  void OnZeroRefCount() const override {
    Proxy* proxy = proxy_.exchange(NULL, std::memory_order_acquire);
    if (proxy) {
      {
        SpinLockGuard proxy_guard(proxy->GetMutex());
        DCHECK(proxy->Get() != NULL) << "SetOrphaned() already called.";
        DCHECK_EQ(ref_count_.load(), 0);
        proxy->SetOrphaned();
      }
      proxy->DecrementRefCount();
    }
    delete this;
  }

  std::atomic<int>& GetRefCountRef() { return ref_count_; }

  mutable std::atomic<Proxy*> proxy_;

  template <typename T> friend class SharedPtr;
  template <typename T> friend class WeakReferentPtr;

  DISALLOW_COPY_AND_ASSIGN(WeakReferent);
};

template <typename T>
class WeakReferentPtr {
 public:
  typedef typename ReferentPtr<T>::Type ReferentPtrType;

  WeakReferentPtr() { Reset(NULL); }
  explicit WeakReferentPtr(T* ptr) { Reset(ptr); }
  explicit WeakReferentPtr(const ReferentPtrType& ref_ptr) {
    Reset(ref_ptr.Get());
  }
  WeakReferentPtr(const WeakReferentPtr& other)
      : proxy_(other.proxy_) {}

  ReferentPtrType Acquire() const {
    ReferentPtrType result;

    if (proxy_.Get()) {
      SpinLockGuard proxy_guard(proxy_->GetMutex());
      WeakReferent* referent = proxy_->Get();
      if (!referent) {
      } else {

        if (referent->GetRefCountRef()++) {
          result = referent;
        }
        --referent->GetRefCountRef();
      }
    }

    return result;
  }

  void Reset() {
    Reset(NULL);
  }

  WeakReferentPtr<T>& operator=(const ReferentPtrType& p) {
    Reset(p.Get());
    return *this;
  }

  bool operator==(const WeakReferentPtr& p) const {
    return p.proxy_ == proxy_;
  }

  bool operator!=(const WeakReferentPtr& p) const {
    return p.proxy_ != proxy_;
  }

  int GetUnderlyingRefCountUnsynchronized() const {
    if (WeakReferent::Proxy* proxy = proxy_.Get()) {
      if (WeakReferent* referent = proxy->GetUnsynchronized()) {
        return referent->GetRefCount();
      }
    }
    return 0;
  }

 private:
  void Reset(T* new_referent) {
    proxy_ = NULL;
    if (new_referent) {
      if (new_referent->GetRefCount() == 0)
        LOG(ERROR) << "Input pointer was not owned by a ReferentPtr and will "
                   << "be deleted";
      ReferentPtrType ref_p(new_referent);
      proxy_ = ref_p->GetProxy();
    }
  }

  mutable ReferentPtr<WeakReferent::Proxy>::Type proxy_;
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_WEAKREFERENT_H_