The Tor Browser: comparison xpcom/base/nsAutoPtr.h

--1:000000000000
+:2c8437e9c1f4
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 nsAutoPtr_h___
+#define nsAutoPtr_h___
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionNoteChild.h"
+#include "mozilla/MemoryReporting.h"
+/*****************************************************************************/
+// template <class T> class nsAutoPtrGetterTransfers;
+template <class T>
+class nsAutoPtr
+{
+private:
+void**
+begin_assignment()
+{
+assign(0);
+return reinterpret_cast<void**>(&mRawPtr);
+}
+void
+assign( T* newPtr )
+{
+T* oldPtr = mRawPtr;
+if (newPtr != nullptr && newPtr == oldPtr) {
+NS_RUNTIMEABORT("Logic flaw in the caller");
+}
+mRawPtr = newPtr;
+delete oldPtr;
+}
+// |class Ptr| helps us prevent implicit "copy construction"
+// through |operator T*() const| from a |const nsAutoPtr<T>|
+// because two implicit conversions in a row aren't allowed.
+// It still allows assignment from T* through implicit conversion
+// from |T*| to |nsAutoPtr<T>::Ptr|
+class Ptr
+{
+public:
+Ptr( T* aPtr )
+: mPtr(aPtr)
+{
+}
+operator T*() const
+{
+return mPtr;
+}
+private:
+T* mPtr;
+};
+private:
+T* mRawPtr;
+public:
+typedef T element_type;
+~nsAutoPtr()
+{
+delete mRawPtr;
+}
+// Constructors
+nsAutoPtr()
+: mRawPtr(0)
+// default constructor
+{
+}
+nsAutoPtr( Ptr aRawPtr )
+: mRawPtr(aRawPtr)
+// construct from a raw pointer (of the right type)
+{
+}
+// This constructor shouldn't exist; we should just use the &&
+// constructor.
+nsAutoPtr( nsAutoPtr<T>& aSmartPtr )
+: mRawPtr( aSmartPtr.forget() )
+// Construct by transferring ownership from another smart pointer.
+{
+}
+nsAutoPtr( nsAutoPtr<T>&& aSmartPtr )
+: mRawPtr( aSmartPtr.forget() )
+// Construct by transferring ownership from another smart pointer.
+{
+}
+// Assignment operators
+nsAutoPtr<T>&
+operator=( T* rhs )
+// assign from a raw pointer (of the right type)
+{
+assign(rhs);
+return *this;
+}
+nsAutoPtr<T>& operator=( nsAutoPtr<T>& rhs )
+// assign by transferring ownership from another smart pointer.
+{
+assign(rhs.forget());
+return *this;
+}
+// Other pointer operators
+T*
+get() const
+/*
+Prefer the implicit conversion provided automatically by
+|operator T*() const|.  Use |get()| _only_ to resolve
+ambiguity.
+*/
+{
+return mRawPtr;
+}
+operator T*() const
+/*
+...makes an |nsAutoPtr| act like its underlying raw pointer
+type  whenever it is used in a context where a raw pointer
+is expected.  It is this operator that makes an |nsAutoPtr|
+substitutable for a raw pointer.
+Prefer the implicit use of this operator to calling |get()|,
+except where necessary to resolve ambiguity.
+*/
+{
+return get();
+}
+T*
+forget()
+{
+T* temp = mRawPtr;
+mRawPtr = 0;
+return temp;
+}
+T*
+operator->() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->().");
+return get();
+}
+// This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+// causes internal compiler errors for some MSVC versions.  (It's not
+// clear to me whether it should be needed.)
+#ifndef _MSC_VER
+template <class U, class V>
+U&
+operator->*(U V::* aMember)
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->*().");
+return get()->*aMember;
+}
+#endif
+nsAutoPtr<T>*
+get_address()
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+const nsAutoPtr<T>*
+get_address() const
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+public:
+T&
+operator*() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator*().");
+return *get();
+}
+T**
+StartAssignment()
+{
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+return reinterpret_cast<T**>(begin_assignment());
+#else
+assign(0);
+return reinterpret_cast<T**>(&mRawPtr);
+#endif
+}
+};
+template <class T>
+inline
+nsAutoPtr<T>*
+address_of( nsAutoPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+inline
+const nsAutoPtr<T>*
+address_of( const nsAutoPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+class nsAutoPtrGetterTransfers
+/*
+...
+This class is designed to be used for anonymous temporary objects in the
+argument list of calls that return COM interface pointers, e.g.,
+nsAutoPtr<IFoo> fooP;
+...->GetTransferedPointer(getter_Transfers(fooP))
+DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+When initialized with a |nsAutoPtr|, as in the example above, it returns
+a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+outer call (|GetTransferedPointer| in this case) can fill in.
+This type should be a nested class inside |nsAutoPtr<T>|.
+*/
+{
+public:
+explicit
+nsAutoPtrGetterTransfers( nsAutoPtr<T>& aSmartPtr )
+: mTargetSmartPtr(aSmartPtr)
+{
+// nothing else to do
+}
+operator void**()
+{
+return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+}
+operator T**()
+{
+return mTargetSmartPtr.StartAssignment();
+}
+T*&
+operator*()
+{
+return *(mTargetSmartPtr.StartAssignment());
+}
+private:
+nsAutoPtr<T>& mTargetSmartPtr;
+};
+template <class T>
+inline
+nsAutoPtrGetterTransfers<T>
+getter_Transfers( nsAutoPtr<T>& aSmartPtr )
+/*
+Used around a |nsAutoPtr| when
+...makes the class |nsAutoPtrGetterTransfers<T>| invisible.
+*/
+{
+return nsAutoPtrGetterTransfers<T>(aSmartPtr);
+}
+// Comparing two |nsAutoPtr|s
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
+// Comparing an |nsAutoPtr| to a raw pointer
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsAutoPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsAutoPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsAutoPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsAutoPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+#endif
+// Comparing an |nsAutoPtr| to |0|
+template <class T>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+template <class T>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr != 0|
+{
+return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
+// specifically to allow |0 != smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
+template <class T>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, int rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( int lhs, const nsAutoPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+/*****************************************************************************/
+// template <class T> class nsAutoArrayPtrGetterTransfers;
+template <class T>
+class nsAutoArrayPtr
+{
+private:
+void**
+begin_assignment()
+{
+assign(0);
+return reinterpret_cast<void**>(&mRawPtr);
+}
+void
+assign( T* newPtr )
+{
+T* oldPtr = mRawPtr;
+mRawPtr = newPtr;
+delete [] oldPtr;
+}
+private:
+T* mRawPtr;
+public:
+typedef T element_type;
+~nsAutoArrayPtr()
+{
+delete [] mRawPtr;
+}
+// Constructors
+nsAutoArrayPtr()
+: mRawPtr(0)
+// default constructor
+{
+}
+nsAutoArrayPtr( T* aRawPtr )
+: mRawPtr(aRawPtr)
+// construct from a raw pointer (of the right type)
+{
+}
+nsAutoArrayPtr( nsAutoArrayPtr<T>& aSmartPtr )
+: mRawPtr( aSmartPtr.forget() )
+// Construct by transferring ownership from another smart pointer.
+{
+}
+// Assignment operators
+nsAutoArrayPtr<T>&
+operator=( T* rhs )
+// assign from a raw pointer (of the right type)
+{
+assign(rhs);
+return *this;
+}
+nsAutoArrayPtr<T>& operator=( nsAutoArrayPtr<T>& rhs )
+// assign by transferring ownership from another smart pointer.
+{
+assign(rhs.forget());
+return *this;
+}
+// Other pointer operators
+T*
+get() const
+/*
+Prefer the implicit conversion provided automatically by
+|operator T*() const|.  Use |get()| _only_ to resolve
+ambiguity.
+*/
+{
+return mRawPtr;
+}
+operator T*() const
+/*
+...makes an |nsAutoArrayPtr| act like its underlying raw pointer
+type  whenever it is used in a context where a raw pointer
+is expected.  It is this operator that makes an |nsAutoArrayPtr|
+substitutable for a raw pointer.
+Prefer the implicit use of this operator to calling |get()|,
+except where necessary to resolve ambiguity.
+*/
+{
+return get();
+}
+T*
+forget()
+{
+T* temp = mRawPtr;
+mRawPtr = 0;
+return temp;
+}
+T*
+operator->() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator->().");
+return get();
+}
+nsAutoArrayPtr<T>*
+get_address()
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+const nsAutoArrayPtr<T>*
+get_address() const
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+public:
+T&
+operator*() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator*().");
+return *get();
+}
+T**
+StartAssignment()
+{
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+return reinterpret_cast<T**>(begin_assignment());
+#else
+assign(0);
+return reinterpret_cast<T**>(&mRawPtr);
+#endif
+}
+size_t
+SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+{
+return aMallocSizeOf(mRawPtr);
+}
+size_t
+SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+};
+template <class T>
+inline
+nsAutoArrayPtr<T>*
+address_of( nsAutoArrayPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+inline
+const nsAutoArrayPtr<T>*
+address_of( const nsAutoArrayPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+class nsAutoArrayPtrGetterTransfers
+/*
+...
+This class is designed to be used for anonymous temporary objects in the
+argument list of calls that return COM interface pointers, e.g.,
+nsAutoArrayPtr<IFoo> fooP;
+...->GetTransferedPointer(getter_Transfers(fooP))
+DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+When initialized with a |nsAutoArrayPtr|, as in the example above, it returns
+a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+outer call (|GetTransferedPointer| in this case) can fill in.
+This type should be a nested class inside |nsAutoArrayPtr<T>|.
+*/
+{
+public:
+explicit
+nsAutoArrayPtrGetterTransfers( nsAutoArrayPtr<T>& aSmartPtr )
+: mTargetSmartPtr(aSmartPtr)
+{
+// nothing else to do
+}
+operator void**()
+{
+return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+}
+operator T**()
+{
+return mTargetSmartPtr.StartAssignment();
+}
+T*&
+operator*()
+{
+return *(mTargetSmartPtr.StartAssignment());
+}
+private:
+nsAutoArrayPtr<T>& mTargetSmartPtr;
+};
+template <class T>
+inline
+nsAutoArrayPtrGetterTransfers<T>
+getter_Transfers( nsAutoArrayPtr<T>& aSmartPtr )
+/*
+Used around a |nsAutoArrayPtr| when
+...makes the class |nsAutoArrayPtrGetterTransfers<T>| invisible.
+*/
+{
+return nsAutoArrayPtrGetterTransfers<T>(aSmartPtr);
+}
+// Comparing two |nsAutoArrayPtr|s
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
+// Comparing an |nsAutoArrayPtr| to a raw pointer
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsAutoArrayPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsAutoArrayPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsAutoArrayPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsAutoArrayPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+#endif
+// Comparing an |nsAutoArrayPtr| to |0|
+template <class T>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+template <class T>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr != 0|
+{
+return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
+// specifically to allow |0 != smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
+template <class T>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, int rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( int lhs, const nsAutoArrayPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+/*****************************************************************************/
+// template <class T> class nsRefPtrGetterAddRefs;
+template <class T>
+class nsRefPtr
+{
+private:
+void
+assign_with_AddRef( T* rawPtr )
+{
+if ( rawPtr )
+rawPtr->AddRef();
+assign_assuming_AddRef(rawPtr);
+}
+void**
+begin_assignment()
+{
+assign_assuming_AddRef(0);
+return reinterpret_cast<void**>(&mRawPtr);
+}
+void
+assign_assuming_AddRef( T* newPtr )
+{
+T* oldPtr = mRawPtr;
+mRawPtr = newPtr;
+if ( oldPtr )
+oldPtr->Release();
+}
+private:
+T* mRawPtr;
+public:
+typedef T element_type;
+~nsRefPtr()
+{
+if ( mRawPtr )
+mRawPtr->Release();
+}
+// Constructors
+nsRefPtr()
+: mRawPtr(0)
+// default constructor
+{
+}
+nsRefPtr(const nsRefPtr<T>& aSmartPtr)
+: mRawPtr(aSmartPtr.mRawPtr)
+// copy-constructor
+{
+if ( mRawPtr )
+mRawPtr->AddRef();
+}
+nsRefPtr(nsRefPtr<T>&& aRefPtr)
+: mRawPtr(aRefPtr.mRawPtr)
+{
+aRefPtr.mRawPtr = nullptr;
+}
+// construct from a raw pointer (of the right type)
+nsRefPtr(T* aRawPtr)
+: mRawPtr(aRawPtr)
+{
+if ( mRawPtr )
+mRawPtr->AddRef();
+}
+template <typename I>
+nsRefPtr( already_AddRefed<I>& aSmartPtr )
+: mRawPtr(aSmartPtr.take())
+// construct from |already_AddRefed|
+{
+}
+template <typename I>
+nsRefPtr( already_AddRefed<I>&& aSmartPtr )
+: mRawPtr(aSmartPtr.take())
+// construct from |otherRefPtr.forget()|
+{
+}
+nsRefPtr( const nsCOMPtr_helper& helper )
+{
+void* newRawPtr;
+if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+newRawPtr = 0;
+mRawPtr = static_cast<T*>(newRawPtr);
+}
+// Assignment operators
+nsRefPtr<T>&
+operator=(const nsRefPtr<T>& rhs)
+// copy assignment operator
+{
+assign_with_AddRef(rhs.mRawPtr);
+return *this;
+}
+nsRefPtr<T>&
+operator=( T* rhs )
+// assign from a raw pointer (of the right type)
+{
+assign_with_AddRef(rhs);
+return *this;
+}
+template <typename I>
+nsRefPtr<T>&
+operator=( already_AddRefed<I>& rhs )
+// assign from |already_AddRefed|
+{
+assign_assuming_AddRef(rhs.take());
+return *this;
+}
+template <typename I>
+nsRefPtr<T>&
+operator=( already_AddRefed<I>&& rhs )
+// assign from |otherRefPtr.forget()|
+{
+assign_assuming_AddRef(rhs.take());
+return *this;
+}
+nsRefPtr<T>&
+operator=( const nsCOMPtr_helper& helper )
+{
+void* newRawPtr;
+if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+newRawPtr = 0;
+assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+return *this;
+}
+nsRefPtr<T>&
+operator=(nsRefPtr<T>&& aRefPtr)
+{
+assign_assuming_AddRef(aRefPtr.mRawPtr);
+aRefPtr.mRawPtr = nullptr;
+return *this;
+}
+// Other pointer operators
+void
+swap( nsRefPtr<T>& rhs )
+// ...exchange ownership with |rhs|; can save a pair of refcount operations
+{
+T* temp = rhs.mRawPtr;
+rhs.mRawPtr = mRawPtr;
+mRawPtr = temp;
+}
+void
+swap( T*& rhs )
+// ...exchange ownership with |rhs|; can save a pair of refcount operations
+{
+T* temp = rhs;
+rhs = mRawPtr;
+mRawPtr = temp;
+}
+already_AddRefed<T>
+forget()
+// return the value of mRawPtr and null out mRawPtr. Useful for
+// already_AddRefed return values.
+{
+T* temp = 0;
+swap(temp);
+return already_AddRefed<T>(temp);
+}
+template <typename I>
+void
+forget( I** rhs)
+// Set the target of rhs to the value of mRawPtr and null out mRawPtr.
+// Useful to avoid unnecessary AddRef/Release pairs with "out"
+// parameters where rhs bay be a T** or an I** where I is a base class
+// of T.
+{
+NS_ASSERTION(rhs, "Null pointer passed to forget!");
+*rhs = mRawPtr;
+mRawPtr = 0;
+}
+T*
+get() const
+/*
+Prefer the implicit conversion provided automatically by |operator T*() const|.
+Use |get()| to resolve ambiguity or to get a castable pointer.
+*/
+{
+return const_cast<T*>(mRawPtr);
+}
+operator T*() const
+/*
+...makes an |nsRefPtr| act like its underlying raw pointer type whenever it
+is used in a context where a raw pointer is expected.  It is this operator
+that makes an |nsRefPtr| substitutable for a raw pointer.
+Prefer the implicit use of this operator to calling |get()|, except where
+necessary to resolve ambiguity.
+*/
+{
+return get();
+}
+T*
+operator->() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->().");
+return get();
+}
+// This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+// causes internal compiler errors for some MSVC versions.  (It's not
+// clear to me whether it should be needed.)
+#ifndef _MSC_VER
+template <class U, class V>
+U&
+operator->*(U V::* aMember)
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->*().");
+return get()->*aMember;
+}
+#endif
+nsRefPtr<T>*
+get_address()
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+const nsRefPtr<T>*
+get_address() const
+// This is not intended to be used by clients.  See |address_of|
+// below.
+{
+return this;
+}
+public:
+T&
+operator*() const
+{
+NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator*().");
+return *get();
+}
+T**
+StartAssignment()
+{
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+return reinterpret_cast<T**>(begin_assignment());
+#else
+assign_assuming_AddRef(0);
+return reinterpret_cast<T**>(&mRawPtr);
+#endif
+}
+};
+template <typename T>
+inline void
+ImplCycleCollectionUnlink(nsRefPtr<T>& aField)
+{
+aField = nullptr;
+}
+template <typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+nsRefPtr<T>& aField,
+const char* aName,
+uint32_t aFlags = 0)
+{
+CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+template <class T>
+inline
+nsRefPtr<T>*
+address_of( nsRefPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+inline
+const nsRefPtr<T>*
+address_of( const nsRefPtr<T>& aPtr )
+{
+return aPtr.get_address();
+}
+template <class T>
+class nsRefPtrGetterAddRefs
+/*
+...
+This class is designed to be used for anonymous temporary objects in the
+argument list of calls that return COM interface pointers, e.g.,
+nsRefPtr<IFoo> fooP;
+...->GetAddRefedPointer(getter_AddRefs(fooP))
+DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
+When initialized with a |nsRefPtr|, as in the example above, it returns
+a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+outer call (|GetAddRefedPointer| in this case) can fill in.
+This type should be a nested class inside |nsRefPtr<T>|.
+*/
+{
+public:
+explicit
+nsRefPtrGetterAddRefs( nsRefPtr<T>& aSmartPtr )
+: mTargetSmartPtr(aSmartPtr)
+{
+// nothing else to do
+}
+operator void**()
+{
+return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+}
+operator T**()
+{
+return mTargetSmartPtr.StartAssignment();
+}
+T*&
+operator*()
+{
+return *(mTargetSmartPtr.StartAssignment());
+}
+private:
+nsRefPtr<T>& mTargetSmartPtr;
+};
+template <class T>
+inline
+nsRefPtrGetterAddRefs<T>
+getter_AddRefs( nsRefPtr<T>& aSmartPtr )
+/*
+Used around a |nsRefPtr| when
+...makes the class |nsRefPtrGetterAddRefs<T>| invisible.
+*/
+{
+return nsRefPtrGetterAddRefs<T>(aSmartPtr);
+}
+// Comparing two |nsRefPtr|s
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
+// Comparing an |nsRefPtr| to a raw pointer
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsRefPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, const U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsRefPtr<T>& rhs )
+{
+return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsRefPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, U* rhs )
+{
+return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsRefPtr<T>& rhs )
+{
+return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
+#endif
+// Comparing an |nsRefPtr| to |0|
+template <class T>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+template <class T>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
+// specifically to allow |smartPtr != 0|
+{
+return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
+// specifically to allow |0 != smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
+template <class T>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, int rhs )
+// specifically to allow |smartPtr == 0|
+{
+return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
+template <class T>
+inline
+bool
+operator==( int lhs, const nsRefPtr<T>& rhs )
+// specifically to allow |0 == smartPtr|
+{
+return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+template <class SourceType, class DestinationType>
+inline
+nsresult
+CallQueryInterface( nsRefPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr )
+{
+return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+}
+/*****************************************************************************/
+template<class T>
+class nsQueryObject : public nsCOMPtr_helper
+{
+public:
+nsQueryObject(T* aRawPtr)
+: mRawPtr(aRawPtr) {}
+virtual nsresult NS_FASTCALL operator()( const nsIID& aIID, void** aResult ) const {
+nsresult status = mRawPtr ? mRawPtr->QueryInterface(aIID, aResult)
+: NS_ERROR_NULL_POINTER;
+return status;
+}
+private:
+T* mRawPtr;
+};
+template<class T>
+class nsQueryObjectWithError : public nsCOMPtr_helper
+{
+public:
+nsQueryObjectWithError(T* aRawPtr, nsresult* aErrorPtr)
+: mRawPtr(aRawPtr), mErrorPtr(aErrorPtr) {}
+virtual nsresult NS_FASTCALL operator()( const nsIID& aIID, void** aResult ) const {
+nsresult status = mRawPtr ? mRawPtr->QueryInterface(aIID, aResult)
+: NS_ERROR_NULL_POINTER;
+if (mErrorPtr)
+*mErrorPtr = status;
+return status;
+}
+private:
+T* mRawPtr;
+nsresult* mErrorPtr;
+};
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(T* aRawPtr)
+{
+return nsQueryObject<T>(aRawPtr);
+}
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(nsCOMPtr<T>& aRawPtr)
+{
+return nsQueryObject<T>(aRawPtr);
+}
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(nsRefPtr<T>& aRawPtr)
+{
+return nsQueryObject<T>(aRawPtr);
+}
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(T* aRawPtr, nsresult* aErrorPtr)
+{
+return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(nsCOMPtr<T>& aRawPtr, nsresult* aErrorPtr)
+{
+return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(nsRefPtr<T>& aRawPtr, nsresult* aErrorPtr)
+{
+return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+/*****************************************************************************/
+#endif // !defined(nsAutoPtr_h___)

The Tor Browser / file comparison

comparison: xpcom/base/nsAutoPtr.h

xpcom/base/nsAutoPtr.h