gecko-dev/xpcom/glue/nsTWeakRef.h
Nathan Froyd 01583602a9 Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout.  The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.

CLOSED TREE makes big refactorings like this a piece of cake.

 # The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
    xargs perl -p -i -e '
 s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
 s/nsRefPtr ?</RefPtr</g;   # handle declarations and variables
'

 # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h

 # Handle nsRefPtr.h itself, a couple places that define constructors
 # from nsRefPtr, and code generators specially.  We do this here, rather
 # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
 # things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
     mfbt/nsRefPtr.h \
     xpcom/glue/nsCOMPtr.h \
     xpcom/base/OwningNonNull.h \
     ipc/ipdl/ipdl/lower.py \
     ipc/ipdl/ipdl/builtin.py \
     dom/bindings/Codegen.py \
     python/lldbutils/lldbutils/utils.py

 # In our indiscriminate substitution above, we renamed
 # nsRefPtrGetterAddRefs, the class behind getter_AddRefs.  Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
    xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'

if [ -d .git ]; then
    git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
    hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi

--HG--
rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 01:24:48 -04:00

177 lines
3.7 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsTWeakRef_h__
#define nsTWeakRef_h__
#ifndef nsDebug_h___
#include "nsDebug.h"
#endif
/**
* A weak reference class for use with generic C++ objects. NOT THREADSAFE!
*
* Example usage:
*
* class A {
* public:
* A() : mWeakSelf(this) {
* }
* ~A() {
* mWeakSelf.forget();
* }
* void Bar() { printf("Bar!\n"); }
* const nsTWeakRef<A> &AsWeakRef() const { return mWeakSelf; }
* private:
* nsTWeakRef<A> mWeakSelf;
* };
*
* class B {
* public:
* void SetA(const nsTWeakRef<A> &a) {
* mA = a;
* }
* void Foo() {
* if (mA)
* mA->Bar();
* }
* private:
* nsTWeakRef<A> mA;
* };
*
* void Test() {
* B b;
* {
* A a;
* b.SetA(a.AsWeakRef());
* b.Foo(); // prints "Bar!"
* }
* b.Foo(); // prints nothing because |a| has already been destroyed
* }
*
* One can imagine much more complex examples, especially when asynchronous
* event processing is involved.
*
* Keep in mind that you should only ever need a class like this when you have
* multiple instances of B, such that it is not possible for A and B to simply
* have pointers to one another.
*/
template<class Type>
class nsTWeakRef
{
public:
~nsTWeakRef()
{}
/**
* Construct from an object pointer (may be null).
*/
explicit nsTWeakRef(Type* aObj = nullptr)
{
if (aObj) {
mRef = new Inner(aObj);
} else {
mRef = nullptr;
}
}
/**
* Construct from another weak reference object.
*/
explicit nsTWeakRef(const nsTWeakRef<Type>& aOther) : mRef(aOther.mRef)
{}
/**
* Assign from an object pointer.
*/
nsTWeakRef<Type>& operator=(Type* aObj)
{
if (aObj) {
mRef = new Inner(aObj);
} else {
mRef = nullptr;
}
return *this;
}
/**
* Assign from another weak reference object.
*/
nsTWeakRef<Type>& operator=(const nsTWeakRef<Type>& aOther)
{
mRef = aOther.mRef;
return *this;
}
/**
* Get the referenced object. This method may return null if the reference
* has been cleared or if an out-of-memory error occurred at assignment.
*/
Type* get() const { return mRef ? mRef->mObj : nullptr; }
/**
* Called to "null out" the weak reference. Typically, the object referenced
* by this weak reference calls this method when it is being destroyed.
* @returns The former referenced object.
*/
Type* forget()
{
Type* obj;
if (mRef) {
obj = mRef->mObj;
mRef->mObj = nullptr;
mRef = nullptr;
} else {
obj = nullptr;
}
return obj;
}
/**
* Allow |*this| to be treated as a |Type*| for convenience.
*/
operator Type*() const { return get(); }
/**
* Allow |*this| to be treated as a |Type*| for convenience. Use with
* caution since this method will crash if the referenced object is null.
*/
Type* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
{
NS_ASSERTION(mRef && mRef->mObj,
"You can't dereference a null weak reference with operator->().");
return get();
}
private:
struct Inner
{
int mCnt;
Type* mObj;
explicit Inner(Type* aObj)
: mCnt(1)
, mObj(aObj)
{
}
void AddRef()
{
++mCnt;
}
void Release()
{
if (--mCnt == 0) {
delete this;
}
}
};
RefPtr<Inner> mRef;
};
#endif // nsTWeakRef_h__