blob: 5db384f334fd79d11989dd9323c11ed42cb8b4f6 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CORE_FXCRT_CFX_RETAIN_PTR_H_
#define CORE_FXCRT_CFX_RETAIN_PTR_H_
#include <functional>
#include <memory>
#include <utility>
#include "core/fxcrt/fx_memory.h"
// Analogous to base's scoped_refptr.
template <class T>
class CFX_RetainPtr {
public:
explicit CFX_RetainPtr(T* pObj) : m_pObj(pObj) {
if (m_pObj)
m_pObj->Retain();
}
CFX_RetainPtr() {}
CFX_RetainPtr(const CFX_RetainPtr& that) : CFX_RetainPtr(that.Get()) {}
CFX_RetainPtr(CFX_RetainPtr&& that) { Swap(that); }
// Deliberately implicit to allow returning nullptrs.
CFX_RetainPtr(std::nullptr_t ptr) {}
template <class U>
CFX_RetainPtr(const CFX_RetainPtr<U>& that) : CFX_RetainPtr(that.Get()) {}
template <class U>
CFX_RetainPtr<U> As() const {
return CFX_RetainPtr<U>(static_cast<U*>(Get()));
}
void Reset(T* obj = nullptr) {
if (obj)
obj->Retain();
m_pObj.reset(obj);
}
T* Get() const { return m_pObj.get(); }
void Swap(CFX_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); }
CFX_RetainPtr& operator=(const CFX_RetainPtr& that) {
if (*this != that)
Reset(that.Get());
return *this;
}
CFX_RetainPtr& operator=(CFX_RetainPtr&& that) {
m_pObj.reset(that.Leak());
return *this;
}
bool operator==(const CFX_RetainPtr& that) const {
return Get() == that.Get();
}
bool operator!=(const CFX_RetainPtr& that) const { return !(*this == that); }
bool operator<(const CFX_RetainPtr& that) const {
return std::less<T*>()(Get(), that.Get());
}
explicit operator bool() const { return !!m_pObj; }
T& operator*() const { return *m_pObj.get(); }
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 CFX_Retainable {
public:
bool HasOneRef() const { return m_nRefCount == 1; }
protected:
virtual ~CFX_Retainable() {}
private:
template <typename U>
friend struct ReleaseDeleter;
template <typename U>
friend class CFX_RetainPtr;
void Retain() { ++m_nRefCount; }
void Release() {
ASSERT(m_nRefCount > 0);
if (--m_nRefCount == 0)
delete this;
}
intptr_t m_nRefCount = 0;
};
namespace pdfium {
// Helper to make a CFX_RetainPtr along the lines of std::make_unique<>(),
// or pdfium::MakeUnique<>(). Arguments are forwarded to T's constructor.
// Classes managed by CFX_RetainPtr should have protected (or private)
// constructors, and should friend this function.
template <typename T, typename... Args>
CFX_RetainPtr<T> MakeRetain(Args&&... args) {
return CFX_RetainPtr<T>(new T(std::forward<Args>(args)...));
}
} // namespace pdfium
#endif // CORE_FXCRT_CFX_RETAIN_PTR_H_
|
