Lines Matching defs:that
4 * Use of this source code is governed by a BSD-style license that can be
22 SkRefCntBase is the base class for objects that may be shared by multiple
36 /** Destruct, asserting that the reference count is 1.
47 * Ensures that all previous owner's actions are complete.
68 decrement, then delete the object. Note that if this is the case, then
156 // This is a variant of SkRefCnt that's Not Virtual, so weighs 4 bytes instead of 8 or 16.
186 // refs are known to be isolated to the current thread. That is, it is known that there are at
209 * Shared pointer class to wrap classes that support a ref()/unref() interface.
212 * classes that match the interface, but have different internal choices: e.g. the hosted class
213 * may have its ref/unref be thread-safe, but that is not assumed/imposed by sk_sp.
223 * Shares the underlying object by calling ref(), so that both the argument and the newly
226 sk_sp(const sk_sp<T>& that) : fPtr(SkSafeRef(that.get())) {}
229 sk_sp(const sk_sp<U>& that) : fPtr(SkSafeRef(that.get())) {}
236 sk_sp(sk_sp<T>&& that) : fPtr(that.release()) {}
239 sk_sp(sk_sp<U>&& that) : fPtr(that.release()) {}
259 * sk_sp previously had a reference to an object (i.e. not null) it will call unref() on that
262 sk_sp<T>& operator=(const sk_sp<T>& that) {
263 if (this != &that) {
264 this->reset(SkSafeRef(that.get()));
270 sk_sp<T>& operator=(const sk_sp<U>& that) {
271 this->reset(SkSafeRef(that.get()));
277 * a reference to another object, unref() will be called on that object. No call to ref()
280 sk_sp<T>& operator=(sk_sp<T>&& that) {
281 this->reset(that.release());
286 sk_sp<T>& operator=(sk_sp<U>&& that) {
287 this->reset(that.release());
325 void swap(sk_sp<T>& that) /*noexcept*/ {
327 swap(fPtr, that.fPtr);