The Tor Browser: xpcom/base/nsAutoPtr.h@6474c204b198 (annotated)

xpcom/base/nsAutoPtr.h@6474c204b198 (annotated)

xpcom/base/nsAutoPtr.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 / annotate

xpcom/base/nsAutoPtr.h@6474c204b198 (annotated)

xpcom/base/nsAutoPtr.h