| /* | |
| * Copyright 2011 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. | |
| */ | |
| // Originally these classes are from Chromium. | |
| // http://src.chromium.org/viewvc/chrome/trunk/src/base/memory/ref_counted.h?view=markup | |
| // | |
| // 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. | |
| // } | |
| // | |
| #ifndef WEBRTC_BASE_SCOPED_REF_PTR_H_ | |
| #define WEBRTC_BASE_SCOPED_REF_PTR_H_ | |
| #include <memory> | |
| namespace rtc { | |
| 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(); | |
| } | |
| // Move constructors. | |
| scoped_refptr(scoped_refptr<T>&& r) : ptr_(r.release()) {} | |
| template <typename U> | |
| scoped_refptr(scoped_refptr<U>&& r) : ptr_(r.release()) {} | |
| ~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(); | |
| } | |
| scoped_refptr<T>& operator=(scoped_refptr<T>&& r) { | |
| scoped_refptr<T>(std::move(r)).swap(*this); | |
| return *this; | |
| } | |
| template <typename U> | |
| scoped_refptr<T>& operator=(scoped_refptr<U>&& r) { | |
| scoped_refptr<T>(std::move(r)).swap(*this); | |
| return *this; | |
| } | |
| void swap(T** pp) { | |
| T* p = ptr_; | |
| ptr_ = *pp; | |
| *pp = p; | |
| } | |
| void swap(scoped_refptr<T>& r) { | |
| swap(&r.ptr_); | |
| } | |
| protected: | |
| T* ptr_; | |
| }; | |
| } // namespace rtc | |
| #endif // WEBRTC_BASE_SCOPED_REF_PTR_H_ |