blob: cb08387bb9fe331ba6876b50685b7e1680ddc81c (
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkTLazy_DEFINED
#define SkTLazy_DEFINED
#include "../private/SkTemplates.h"
#include "SkTypes.h"
#include <new>
#include <utility>
/**
* Efficient way to defer allocating/initializing a class until it is needed
* (if ever).
*/
template <typename T> class SkTLazy {
public:
SkTLazy() : fPtr(nullptr) {}
explicit SkTLazy(const T* src)
: fPtr(src ? new (fStorage.get()) T(*src) : nullptr) {}
SkTLazy(const SkTLazy& src) : fPtr(nullptr) { *this = src; }
~SkTLazy() {
if (this->isValid()) {
fPtr->~T();
}
}
SkTLazy& operator=(const SkTLazy& src) {
if (src.isValid()) {
this->set(*src.get());
} else {
this->reset();
}
return *this;
}
/**
* Return a pointer to an instance of the class initialized with 'args'.
* If a previous instance had been initialized (either from init() or
* set()) it will first be destroyed, so that a freshly initialized
* instance is always returned.
*/
template <typename... Args> T* init(Args&&... args) {
if (this->isValid()) {
fPtr->~T();
}
fPtr = new (SkTCast<T*>(fStorage.get())) T(std::forward<Args>(args)...);
return fPtr;
}
/**
* Copy src into this, and return a pointer to a copy of it. Note this
* will always return the same pointer, so if it is called on a lazy that
* has already been initialized, then this will copy over the previous
* contents.
*/
T* set(const T& src) {
if (this->isValid()) {
*fPtr = src;
} else {
fPtr = new (SkTCast<T*>(fStorage.get())) T(src);
}
return fPtr;
}
/**
* Destroy the lazy object (if it was created via init() or set())
*/
void reset() {
if (this->isValid()) {
fPtr->~T();
fPtr = nullptr;
}
}
/**
* Returns true if a valid object has been initialized in the SkTLazy,
* false otherwise.
*/
bool isValid() const { return SkToBool(fPtr); }
/**
* Returns the object. This version should only be called when the caller
* knows that the object has been initialized.
*/
T* get() const { SkASSERT(this->isValid()); return fPtr; }
/**
* Like above but doesn't assert if object isn't initialized (in which case
* nullptr is returned).
*/
T* getMaybeNull() const { return fPtr; }
private:
SkAlignedSTStorage<1, T> fStorage;
T* fPtr; // nullptr or fStorage
};
/**
* A helper built on top of SkTLazy to do copy-on-first-write. The object is initialized
* with a const pointer but provides a non-const pointer accessor. The first time the
* accessor is called (if ever) the object is cloned.
*
* In the following example at most one copy of constThing is made:
*
* SkTCopyOnFirstWrite<Thing> thing(&constThing);
* ...
* function_that_takes_a_const_thing_ptr(thing); // constThing is passed
* ...
* if (need_to_modify_thing()) {
* thing.writable()->modifyMe(); // makes a copy of constThing
* }
* ...
* x = thing->readSomething();
* ...
* if (need_to_modify_thing_now()) {
* thing.writable()->changeMe(); // makes a copy of constThing if we didn't call modifyMe()
* }
*
* consume_a_thing(thing); // could be constThing or a modified copy.
*/
template <typename T>
class SkTCopyOnFirstWrite {
public:
SkTCopyOnFirstWrite(const T& initial) : fObj(&initial) {}
SkTCopyOnFirstWrite(const T* initial) : fObj(initial) {}
// Constructor for delayed initialization.
SkTCopyOnFirstWrite() : fObj(nullptr) {}
// Should only be called once, and only if the default constructor was used.
void init(const T& initial) {
SkASSERT(nullptr == fObj);
SkASSERT(!fLazy.isValid());
fObj = &initial;
}
/**
* Returns a writable T*. The first time this is called the initial object is cloned.
*/
T* writable() {
SkASSERT(fObj);
if (!fLazy.isValid()) {
fLazy.set(*fObj);
fObj = fLazy.get();
}
return const_cast<T*>(fObj);
}
/**
* Operators for treating this as though it were a const pointer.
*/
const T *operator->() const { return fObj; }
operator const T*() const { return fObj; }
const T& operator *() const { return *fObj; }
private:
const T* fObj;
SkTLazy<T> fLazy;
};
#endif
|
