LCOV - code coverage report
Current view: directory - objdir/dist/include - nsCOMArray.h (source / functions) Found Hit Coverage
Test: app.info Lines: 72 56 77.8 %
Date: 2012-06-02 Functions: 761 333 43.8 %

       1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2                 : /* ***** BEGIN LICENSE BLOCK *****
       3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       4                 :  *
       5                 :  * The contents of this file are subject to the Mozilla Public License Version
       6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       7                 :  * the License. You may obtain a copy of the License at
       8                 :  * http://www.mozilla.org/MPL/
       9                 :  *
      10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      12                 :  * for the specific language governing rights and limitations under the
      13                 :  * License.
      14                 :  *
      15                 :  * The Original Code is a COM aware array class.
      16                 :  *
      17                 :  * The Initial Developer of the Original Code is
      18                 :  * Netscape Communications Corp.
      19                 :  * Portions created by the Initial Developer are Copyright (C) 2002
      20                 :  * the Initial Developer. All Rights Reserved.
      21                 :  *
      22                 :  * Contributor(s):
      23                 :  *   Alec Flett <alecf@netscape.com>
      24                 :  *
      25                 :  * Alternatively, the contents of this file may be used under the terms of
      26                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
      27                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      29                 :  * of those above. If you wish to allow use of your version of this file only
      30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      31                 :  * use your version of this file under the terms of the MPL, indicate your
      32                 :  * decision by deleting the provisions above and replace them with the notice
      33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      34                 :  * the provisions above, a recipient may use your version of this file under
      35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      36                 :  *
      37                 :  * ***** END LICENSE BLOCK ***** */
      38                 : 
      39                 : #ifndef nsCOMArray_h__
      40                 : #define nsCOMArray_h__
      41                 : 
      42                 : #include "mozilla/Attributes.h"
      43                 : 
      44                 : #include "nsVoidArray.h"
      45                 : #include "nsISupports.h"
      46                 : 
      47                 : // See below for the definition of nsCOMArray<T>
      48                 : 
      49                 : // a class that's nsISupports-specific, so that we can contain the
      50                 : // work of this class in the XPCOM dll
      51                 : class NS_COM_GLUE nsCOMArray_base
      52                 : {
      53                 :     friend class nsArray;
      54                 : protected:
      55          255963 :     nsCOMArray_base() {}
      56            4352 :     nsCOMArray_base(PRInt32 aCount) : mArray(aCount) {}
      57                 :     nsCOMArray_base(const nsCOMArray_base& other);
      58                 :     ~nsCOMArray_base();
      59                 : 
      60           32521 :     PRInt32 IndexOf(nsISupports* aObject) const {
      61           32521 :         return mArray.IndexOf(aObject);
      62                 :     }
      63                 : 
      64                 :     PRInt32 IndexOfObject(nsISupports* aObject) const;
      65                 : 
      66               0 :     bool EnumerateForwards(nsVoidArrayEnumFunc aFunc, void* aData) {
      67               0 :         return mArray.EnumerateForwards(aFunc, aData);
      68                 :     }
      69                 :     
      70               0 :     bool EnumerateBackwards(nsVoidArrayEnumFunc aFunc, void* aData) {
      71               0 :         return mArray.EnumerateBackwards(aFunc, aData);
      72                 :     }
      73                 :     
      74            3935 :     void Sort(nsVoidArrayComparatorFunc aFunc, void* aData) {
      75            3935 :         mArray.Sort(aFunc, aData);
      76            3935 :     }
      77                 :     
      78                 :     // any method which is not a direct forward to mArray should
      79                 :     // avoid inline bodies, so that the compiler doesn't inline them
      80                 :     // all over the place
      81                 :     void Clear();
      82                 :     bool InsertObjectAt(nsISupports* aObject, PRInt32 aIndex);
      83                 :     bool InsertObjectsAt(const nsCOMArray_base& aObjects, PRInt32 aIndex);
      84                 :     bool ReplaceObjectAt(nsISupports* aObject, PRInt32 aIndex);
      85          176114 :     bool AppendObject(nsISupports *aObject) {
      86          176114 :         return InsertObjectAt(aObject, Count());
      87                 :     }
      88            4721 :     bool AppendObjects(const nsCOMArray_base& aObjects) {
      89            4721 :         return InsertObjectsAt(aObjects, Count());
      90                 :     }
      91                 :     bool RemoveObject(nsISupports *aObject);
      92                 :     bool RemoveObjectAt(PRInt32 aIndex);
      93                 :     bool RemoveObjectsAt(PRInt32 aIndex, PRInt32 aCount);
      94                 : 
      95                 : public:
      96                 :     // override nsVoidArray stuff so that they can be accessed by
      97                 :     // consumers of nsCOMArray
      98         1261547 :     PRInt32 Count() const {
      99         1261547 :         return mArray.Count();
     100                 :     }
     101                 :     // If the array grows, the newly created entries will all be null;
     102                 :     // if the array shrinks, the excess entries will all be released.
     103                 :     bool SetCount(PRInt32 aNewCount);
     104                 : 
     105          668558 :     nsISupports* ObjectAt(PRInt32 aIndex) const {
     106          668558 :         return static_cast<nsISupports*>(mArray.FastElementAt(aIndex));
     107                 :     }
     108                 :     
     109            2384 :     nsISupports* SafeObjectAt(PRInt32 aIndex) const {
     110            2384 :         return static_cast<nsISupports*>(mArray.SafeElementAt(aIndex));
     111                 :     }
     112                 : 
     113               0 :     nsISupports* operator[](PRInt32 aIndex) const {
     114               0 :         return ObjectAt(aIndex);
     115                 :     }
     116                 : 
     117                 :     // Ensures there is enough space to store a total of aCapacity objects.
     118                 :     // This method never deletes any objects.
     119          120606 :     bool SetCapacity(PRUint32 aCapacity) {
     120          120247 :       return aCapacity > 0 ? mArray.SizeTo(static_cast<PRInt32>(aCapacity))
     121          240853 :                            : true;
     122                 :     }
     123                 : 
     124                 :     // Measures the size of the array's element storage, and if
     125                 :     // |aSizeOfElement| is non-NULL, measures the size of things pointed to by
     126                 :     // elements.
     127               0 :     size_t SizeOfExcludingThis(
     128                 :              nsVoidArraySizeOfElementIncludingThisFunc aSizeOfElementIncludingThis,
     129                 :              nsMallocSizeOfFun aMallocSizeOf, void* aData = NULL) const {
     130                 :         return mArray.SizeOfExcludingThis(aSizeOfElementIncludingThis,
     131               0 :                                           aMallocSizeOf, aData);
     132                 :     }
     133                 :     
     134                 : private:
     135                 :     
     136                 :     // the actual storage
     137                 :     nsVoidArray mArray;
     138                 : 
     139                 :     // don't implement these, defaults will muck with refcounts!
     140                 :     nsCOMArray_base& operator=(const nsCOMArray_base& other) MOZ_DELETE;
     141                 : };
     142                 : 
     143                 : // a non-XPCOM, refcounting array of XPCOM objects
     144                 : // used as a member variable or stack variable - this object is NOT
     145                 : // refcounted, but the objects that it holds are
     146                 : //
     147                 : // most of the read-only accessors like ObjectAt()/etc do NOT refcount
     148                 : // on the way out. This means that you can do one of two things:
     149                 : //
     150                 : // * does an addref, but holds onto a reference
     151                 : // nsCOMPtr<T> foo = array[i];
     152                 : //
     153                 : // * avoids the refcount, but foo might go stale if array[i] is ever
     154                 : // * modified/removed. Be careful not to NS_RELEASE(foo)!
     155                 : // T* foo = array[i];
     156                 : //
     157                 : // This array will accept null as an argument for any object, and will
     158                 : // store null in the array, just like nsVoidArray. But that also means
     159                 : // that methods like ObjectAt() may return null when referring to an
     160                 : // existing, but null entry in the array.
     161                 : template <class T>
     162                 : class nsCOMArray : public nsCOMArray_base
     163                 : {
     164                 :  public:
     165          254344 :     nsCOMArray() {}
     166            4352 :     nsCOMArray(PRInt32 aCount) : nsCOMArray_base(aCount) {}
     167                 :     
     168                 :     // only to be used by trusted classes who are going to pass us the
     169                 :     // right type!
     170            1353 :     nsCOMArray(const nsCOMArray<T>& aOther) : nsCOMArray_base(aOther) { }
     171                 : 
     172          260008 :     ~nsCOMArray() {}
     173                 : 
     174                 :     // these do NOT refcount on the way out, for speed
     175          649766 :     T* ObjectAt(PRInt32 aIndex) const {
     176          649766 :         return static_cast<T*>(nsCOMArray_base::ObjectAt(aIndex));
     177                 :     }
     178                 : 
     179                 :     // these do NOT refcount on the way out, for speed
     180            1268 :     T* SafeObjectAt(PRInt32 aIndex) const {
     181            1268 :         return static_cast<T*>(nsCOMArray_base::SafeObjectAt(aIndex));
     182                 :     }
     183                 : 
     184                 :     // indexing operator for syntactic sugar
     185          400992 :     T* operator[](PRInt32 aIndex) const {
     186          400992 :         return ObjectAt(aIndex);
     187                 :     }
     188                 : 
     189                 :     // index of the element in question.. does NOT refcount
     190                 :     // note: this does not check COM object identity. Use
     191                 :     // IndexOfObject() for that purpose
     192           32521 :     PRInt32 IndexOf(T* aObject) const {
     193           32521 :         return nsCOMArray_base::IndexOf(static_cast<nsISupports*>(aObject));
     194                 :     }
     195                 : 
     196                 :     // index of the element in question.. be careful!
     197                 :     // this is much slower than IndexOf() because it uses
     198                 :     // QueryInterface to determine actual COM identity of the object
     199                 :     // if you need to do this frequently then consider enforcing
     200                 :     // COM object identity before adding/comparing elements
     201             198 :     PRInt32 IndexOfObject(T* aObject) const {
     202             198 :         return nsCOMArray_base::IndexOfObject(static_cast<nsISupports*>(aObject));
     203                 :     }
     204                 : 
     205                 :     // inserts aObject at aIndex, shifting the objects at aIndex and
     206                 :     // later to make space
     207          286949 :     bool InsertObjectAt(T* aObject, PRInt32 aIndex) {
     208          286949 :         return nsCOMArray_base::InsertObjectAt(static_cast<nsISupports*>(aObject), aIndex);
     209                 :     }
     210                 : 
     211                 :     // inserts the objects from aObject at aIndex, shifting the
     212                 :     // objects at aIndex and later to make space
     213               0 :     bool InsertObjectsAt(const nsCOMArray<T>& aObjects, PRInt32 aIndex) {
     214               0 :         return nsCOMArray_base::InsertObjectsAt(aObjects, aIndex);
     215                 :     }
     216                 : 
     217                 :     // replaces an existing element. Warning: if the array grows,
     218                 :     // the newly created entries will all be null
     219          237948 :     bool ReplaceObjectAt(T* aObject, PRInt32 aIndex) {
     220          237948 :         return nsCOMArray_base::ReplaceObjectAt(static_cast<nsISupports*>(aObject), aIndex);
     221                 :     }
     222                 : 
     223                 :     // override nsVoidArray stuff so that they can be accessed by
     224                 :     // other methods
     225                 : 
     226                 :     // elements in the array (including null elements!)
     227         1068952 :     PRInt32 Count() const {
     228         1068952 :         return nsCOMArray_base::Count();
     229                 :     }
     230                 : 
     231                 :     // remove all elements in the array, and call NS_RELEASE on each one
     232           30536 :     void Clear() {
     233           30536 :         nsCOMArray_base::Clear();
     234           30536 :     }
     235                 : 
     236                 :     // Enumerator callback function. Return false to stop
     237                 :     // Here's a more readable form:
     238                 :     // bool enumerate(T* aElement, void* aData)
     239                 :     typedef bool (* nsCOMArrayEnumFunc)
     240                 :         (T* aElement, void *aData);
     241                 :     
     242                 :     // enumerate through the array with a callback. 
     243               0 :     bool EnumerateForwards(nsCOMArrayEnumFunc aFunc, void* aData) {
     244                 :         return nsCOMArray_base::EnumerateForwards(nsVoidArrayEnumFunc(aFunc),
     245               0 :                                                   aData);
     246                 :     }
     247                 : 
     248               0 :     bool EnumerateBackwards(nsCOMArrayEnumFunc aFunc, void* aData) {
     249                 :         return nsCOMArray_base::EnumerateBackwards(nsVoidArrayEnumFunc(aFunc),
     250               0 :                                                   aData);
     251                 :     }
     252                 :     
     253                 :     typedef int (* nsCOMArrayComparatorFunc)
     254                 :         (T* aElement1, T* aElement2, void* aData);
     255                 :         
     256            3935 :     void Sort(nsCOMArrayComparatorFunc aFunc, void* aData) {
     257            3935 :         nsCOMArray_base::Sort(nsVoidArrayComparatorFunc(aFunc), aData);
     258            3935 :     }
     259                 : 
     260                 :     // append an object, growing the array as necessary
     261          175122 :     bool AppendObject(T *aObject) {
     262          175122 :         return nsCOMArray_base::AppendObject(static_cast<nsISupports*>(aObject));
     263                 :     }
     264                 : 
     265                 :     // append objects, growing the array as necessary
     266            3368 :     bool AppendObjects(const nsCOMArray<T>& aObjects) {
     267            3368 :         return nsCOMArray_base::AppendObjects(aObjects);
     268                 :     }
     269                 :     
     270                 :     // remove the first instance of the given object and shrink the
     271                 :     // array as necessary
     272                 :     // Warning: if you pass null here, it will remove the first null element
     273           14102 :     bool RemoveObject(T *aObject) {
     274           14102 :         return nsCOMArray_base::RemoveObject(static_cast<nsISupports*>(aObject));
     275                 :     }
     276                 : 
     277                 :     // remove an element at a specific position, shrinking the array
     278                 :     // as necessary
     279             296 :     bool RemoveObjectAt(PRInt32 aIndex) {
     280             296 :         return nsCOMArray_base::RemoveObjectAt(aIndex);
     281                 :     }
     282                 : 
     283                 :     // remove a range of elements at a specific position, shrinking the array
     284                 :     // as necessary
     285               2 :     bool RemoveObjectsAt(PRInt32 aIndex, PRInt32 aCount) {
     286               2 :         return nsCOMArray_base::RemoveObjectsAt(aIndex, aCount);
     287                 :     }
     288                 : 
     289                 :     // Each element in an nsCOMArray<T> is actually a T*, so this function is
     290                 :     // "IncludingThis" rather than "ExcludingThis" because it needs to measure
     291                 :     // the memory taken by the T itself as well as anything it points to.
     292                 :     typedef size_t (* nsCOMArraySizeOfElementIncludingThisFunc)
     293                 :         (T* aElement, nsMallocSizeOfFun aMallocSizeOf, void *aData);
     294                 :     
     295               0 :     size_t SizeOfExcludingThis(
     296                 :              nsCOMArraySizeOfElementIncludingThisFunc aSizeOfElementIncludingThis, 
     297                 :              nsMallocSizeOfFun aMallocSizeOf, void *aData = NULL) const {
     298                 :         return nsCOMArray_base::SizeOfExcludingThis(
     299                 :                  nsVoidArraySizeOfElementIncludingThisFunc(aSizeOfElementIncludingThis),
     300               0 :                  aMallocSizeOf, aData);
     301                 :     }
     302                 : 
     303                 : private:
     304                 : 
     305                 :     // don't implement these!
     306                 :     nsCOMArray<T>& operator=(const nsCOMArray<T>& other) MOZ_DELETE;
     307                 : };
     308                 : 
     309                 : 
     310                 : #endif

Generated by: LCOV version 1.7