mirror of
https://github.com/oxen-io/session-android.git
synced 2024-12-21 07:27:30 +00:00
145 lines
3.5 KiB
C++
145 lines
3.5 KiB
C++
/*
|
|
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef SYSTEM_WRAPPERS_INTERFACE_SCOPED_REFPTR_H_
|
|
#define SYSTEM_WRAPPERS_INTERFACE_SCOPED_REFPTR_H_
|
|
|
|
#include <stddef.h>
|
|
|
|
namespace webrtc {
|
|
|
|
// Extracted from Chromium's src/base/memory/ref_counted.h.
|
|
|
|
//
|
|
// A smart pointer class for reference counted objects. Use this class instead
|
|
// of calling AddRef and Release manually on a reference counted object to
|
|
// avoid common memory leaks caused by forgetting to Release an object
|
|
// reference. Sample usage:
|
|
//
|
|
// class MyFoo : public RefCounted<MyFoo> {
|
|
// ...
|
|
// };
|
|
//
|
|
// void some_function() {
|
|
// scoped_refptr<MyFoo> foo = new MyFoo();
|
|
// foo->Method(param);
|
|
// // |foo| is released when this function returns
|
|
// }
|
|
//
|
|
// void some_other_function() {
|
|
// scoped_refptr<MyFoo> foo = new MyFoo();
|
|
// ...
|
|
// foo = NULL; // explicitly releases |foo|
|
|
// ...
|
|
// if (foo)
|
|
// foo->Method(param);
|
|
// }
|
|
//
|
|
// The above examples show how scoped_refptr<T> acts like a pointer to T.
|
|
// Given two scoped_refptr<T> classes, it is also possible to exchange
|
|
// references between the two objects, like so:
|
|
//
|
|
// {
|
|
// scoped_refptr<MyFoo> a = new MyFoo();
|
|
// scoped_refptr<MyFoo> b;
|
|
//
|
|
// b.swap(a);
|
|
// // now, |b| references the MyFoo object, and |a| references NULL.
|
|
// }
|
|
//
|
|
// To make both |a| and |b| in the above example reference the same MyFoo
|
|
// object, simply use the assignment operator:
|
|
//
|
|
// {
|
|
// scoped_refptr<MyFoo> a = new MyFoo();
|
|
// scoped_refptr<MyFoo> b;
|
|
//
|
|
// b = a;
|
|
// // now, |a| and |b| each own a reference to the same MyFoo object.
|
|
// }
|
|
//
|
|
template <class T>
|
|
class scoped_refptr {
|
|
public:
|
|
scoped_refptr() : ptr_(NULL) {
|
|
}
|
|
|
|
scoped_refptr(T* p) : ptr_(p) {
|
|
if (ptr_)
|
|
ptr_->AddRef();
|
|
}
|
|
|
|
scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
|
|
if (ptr_)
|
|
ptr_->AddRef();
|
|
}
|
|
|
|
template <typename U>
|
|
scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
|
|
if (ptr_)
|
|
ptr_->AddRef();
|
|
}
|
|
|
|
~scoped_refptr() {
|
|
if (ptr_)
|
|
ptr_->Release();
|
|
}
|
|
|
|
T* get() const { return ptr_; }
|
|
operator T*() const { return ptr_; }
|
|
T* operator->() const { return ptr_; }
|
|
|
|
// Release a pointer.
|
|
// The return value is the current pointer held by this object.
|
|
// If this object holds a NULL pointer, the return value is NULL.
|
|
// After this operation, this object will hold a NULL pointer,
|
|
// and will not own the object any more.
|
|
T* release() {
|
|
T* retVal = ptr_;
|
|
ptr_ = NULL;
|
|
return retVal;
|
|
}
|
|
|
|
scoped_refptr<T>& operator=(T* p) {
|
|
// AddRef first so that self assignment should work
|
|
if (p)
|
|
p->AddRef();
|
|
if (ptr_ )
|
|
ptr_->Release();
|
|
ptr_ = p;
|
|
return *this;
|
|
}
|
|
|
|
scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
|
|
return *this = r.ptr_;
|
|
}
|
|
|
|
template <typename U>
|
|
scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
|
|
return *this = r.get();
|
|
}
|
|
|
|
void swap(T** pp) {
|
|
T* p = ptr_;
|
|
ptr_ = *pp;
|
|
*pp = p;
|
|
}
|
|
|
|
void swap(scoped_refptr<T>& r) {
|
|
swap(&r.ptr_);
|
|
}
|
|
|
|
protected:
|
|
T* ptr_;
|
|
};
|
|
} // namespace webrtc
|
|
|
|
#endif // SYSTEM_WRAPPERS_INTERFACE_SCOPED_REFPTR_H_
|