blob: 26223b620c1fffa00970c02f65c02616398b1a93 [file] [log] [blame] [edit]
// Copyright 2016 The PDFium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CORE_FXCRT_RETAIN_PTR_H_
#define CORE_FXCRT_RETAIN_PTR_H_
#include <stdint.h>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
#include "core/fxcrt/unowned_ptr.h"
#include "third_party/base/check.h"
#include "third_party/base/compiler_specific.h"
namespace fxcrt {
// Used with std::unique_ptr to Release() objects that can't be deleted.
template <class T>
struct ReleaseDeleter {
inline void operator()(T* ptr) const { ptr->Release(); }
};
// Analogous to base's scoped_refptr.
template <class T>
class TRIVIAL_ABI RetainPtr {
public:
RetainPtr() noexcept = default;
// Deliberately implicit to allow returning nullptrs.
// NOLINTNEXTLINE(runtime/explicit)
RetainPtr(std::nullptr_t ptr) {}
explicit RetainPtr(T* pObj) noexcept : m_pObj(pObj) {
if (m_pObj)
m_pObj->Retain();
}
// Copy-construct a RetainPtr.
// Required in addition to copy conversion constructor below.
RetainPtr(const RetainPtr& that) noexcept : RetainPtr(that.Get()) {}
// Move-construct a RetainPtr. After construction, |that| will be NULL.
// Required in addition to move conversion constructor below.
RetainPtr(RetainPtr&& that) noexcept { Unleak(that.Leak()); }
// Copy conversion constructor.
template <class U,
typename = typename std::enable_if<
std::is_convertible<U*, T*>::value>::type>
RetainPtr(const RetainPtr<U>& that) : RetainPtr(that.Get()) {}
// Move-conversion constructor.
template <class U,
typename = typename std::enable_if<
std::is_convertible<U*, T*>::value>::type>
RetainPtr(RetainPtr<U>&& that) noexcept {
Unleak(that.Leak());
}
// Assign a RetainPtr from nullptr;
RetainPtr& operator=(std::nullptr_t) noexcept {
Reset();
return *this;
}
// Copy-assign a RetainPtr.
// Required in addition to copy conversion assignment below.
RetainPtr& operator=(const RetainPtr& that) {
if (*this != that)
Reset(that.Get());
return *this;
}
// Move-assign a RetainPtr. After assignment, |that| will be NULL.
// Required in addition to move conversion assignment below.
RetainPtr& operator=(RetainPtr&& that) noexcept {
Unleak(that.Leak());
return *this;
}
// Copy-convert assign a RetainPtr.
template <class U,
typename = typename std::enable_if<
std::is_convertible<U*, T*>::value>::type>
RetainPtr& operator=(const RetainPtr<U>& that) {
if (*this != that)
Reset(that.Get());
return *this;
}
// Move-convert assign a RetainPtr. After assignment, |that| will be NULL.
template <class U,
typename = typename std::enable_if<
std::is_convertible<U*, T*>::value>::type>
RetainPtr& operator=(RetainPtr<U>&& that) noexcept {
Unleak(that.Leak());
return *this;
}
~RetainPtr() = default;
template <class U>
U* AsRaw() const {
return static_cast<U*>(Get());
}
template <class U>
RetainPtr<U> As() const {
return RetainPtr<U>(AsRaw<U>());
}
void Reset(T* obj = nullptr) {
if (obj)
obj->Retain();
m_pObj.reset(obj);
}
operator T*() const noexcept { return Get(); }
T* Get() const noexcept { return m_pObj.get(); }
UnownedPtr<T> BackPointer() const { return UnownedPtr<T>(Get()); }
void Swap(RetainPtr& that) { m_pObj.swap(that.m_pObj); }
// Useful for passing notion of object ownership across a C API.
T* Leak() { return m_pObj.release(); }
void Unleak(T* ptr) { m_pObj.reset(ptr); }
bool operator==(const RetainPtr& that) const { return Get() == that.Get(); }
bool operator!=(const RetainPtr& that) const { return !(*this == that); }
template <typename U>
bool operator==(const U& that) const {
return Get() == that;
}
template <typename U>
bool operator!=(const U& that) const {
return !(*this == that);
}
bool operator<(const RetainPtr& that) const {
return std::less<T*>()(Get(), that.Get());
}
explicit operator bool() const { return !!m_pObj; }
T& operator*() const { return *m_pObj; }
T* operator->() const { return m_pObj.get(); }
private:
std::unique_ptr<T, ReleaseDeleter<T>> m_pObj;
};
// Trivial implementation - internal ref count with virtual destructor.
class Retainable {
public:
Retainable() = default;
bool HasOneRef() const { return m_nRefCount == 1; }
protected:
virtual ~Retainable() = default;
private:
template <typename U>
friend struct ReleaseDeleter;
template <typename U>
friend class RetainPtr;
Retainable(const Retainable& that) = delete;
Retainable& operator=(const Retainable& that) = delete;
// These need to be const methods operating on a mutable member so that
// RetainPtr<const T> can be used for an object that is otherwise const
// apart from the internal ref-counting.
void Retain() const {
++m_nRefCount;
CHECK(m_nRefCount > 0);
}
void Release() const {
CHECK(m_nRefCount > 0);
if (--m_nRefCount == 0)
delete this;
}
mutable uintptr_t m_nRefCount = 0;
static_assert(std::is_unsigned<decltype(m_nRefCount)>::value,
"m_nRefCount must be an unsigned type for overflow check"
"to work properly in Retain()");
};
} // namespace fxcrt
using fxcrt::ReleaseDeleter;
using fxcrt::Retainable;
using fxcrt::RetainPtr;
namespace pdfium {
// Helper to make a RetainPtr along the lines of std::make_unique<>().
// Arguments are forwarded to T's constructor. Classes managed by RetainPtr
// should have protected (or private) constructors, and should friend this
// function.
template <typename T, typename... Args>
RetainPtr<T> MakeRetain(Args&&... args) {
return RetainPtr<T>(new T(std::forward<Args>(args)...));
}
// Type-deducing wrapper to make a RetainPtr from an ordinary pointer,
// since equivalent constructor is explicit.
template <typename T>
RetainPtr<T> WrapRetain(T* that) {
return RetainPtr<T>(that);
}
} // namespace pdfium
// Macro to allow construction via MakeRetain<>() only, when used
// with a private constructor in a class.
#define CONSTRUCT_VIA_MAKE_RETAIN \
template <typename T, typename... Args> \
friend RetainPtr<T> pdfium::MakeRetain(Args&&... args)
#endif // CORE_FXCRT_RETAIN_PTR_H_