xpcom/ds/nsArray.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsArray.h"
   7 #include "nsArrayEnumerator.h"
   8 #include "nsWeakReference.h"
   9 #include "nsThreadUtils.h"
  10
  11 // used by IndexOf()
  12 struct findIndexOfClosure
  13 {
  14     nsISupports *targetElement;
  15     uint32_t startIndex;
  16     uint32_t resultIndex;
  17 };
  18
  19 static bool FindElementCallback(void* aElement, void* aClosure);
  20
  21 NS_INTERFACE_MAP_BEGIN(nsArray)
  22   NS_INTERFACE_MAP_ENTRY(nsIArray)
  23   NS_INTERFACE_MAP_ENTRY(nsIMutableArray)
  24   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMutableArray)
  25 NS_INTERFACE_MAP_END
  26
  27 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsArrayCC)
  28   NS_INTERFACE_MAP_ENTRY(nsIArray)
  29   NS_INTERFACE_MAP_ENTRY(nsIMutableArray)
  30   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMutableArray)
  31 NS_INTERFACE_MAP_END
  32
  33 nsArray::~nsArray()
  34 {
  35     Clear();
  36 }
  37
  38
  39 NS_IMPL_ADDREF(nsArray)
  40 NS_IMPL_RELEASE(nsArray)
  41
  42 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsArrayCC)
  43 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsArrayCC)
  44
  45 NS_IMPL_CYCLE_COLLECTION_CLASS(nsArrayCC)
  46 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsArrayCC)
  47     tmp->Clear();
  48 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  49 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsArrayCC)
  50     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArray)
  51 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  52
  53 NS_IMETHODIMP
  54 nsArray::GetLength(uint32_t* aLength)
  55 {
  56     *aLength = mArray.Count();
  57     return NS_OK;
  58 }
  59
  60 NS_IMETHODIMP
  61 nsArray::QueryElementAt(uint32_t aIndex,
  62                         const nsIID& aIID,
  63                         void ** aResult)
  64 {
  65     nsISupports * obj = mArray.SafeObjectAt(aIndex);
  66     if (!obj) return NS_ERROR_ILLEGAL_VALUE;
  67
  68     // no need to worry about a leak here, because SafeObjectAt()
  69     // doesn't addref its result
  70     return obj->QueryInterface(aIID, aResult);
  71 }
  72
  73 NS_IMETHODIMP
  74 nsArray::IndexOf(uint32_t aStartIndex, nsISupports* aElement,
  75                  uint32_t* aResult)
  76 {
  77     // optimize for the common case by forwarding to mArray
  78     if (aStartIndex == 0) {
  79         uint32_t idx = mArray.IndexOf(aElement);
  80         if (idx == UINT32_MAX)
  81             return NS_ERROR_FAILURE;
  82
  83         *aResult = idx;
  84         return NS_OK;
  85     }
  86
  87     findIndexOfClosure closure = { aElement, aStartIndex, 0 };
  88     bool notFound = mArray.EnumerateForwards(FindElementCallback, &closure);
  89     if (notFound)
  90         return NS_ERROR_FAILURE;
  91
  92     *aResult = closure.resultIndex;
  93     return NS_OK;
  94 }
  95
  96 NS_IMETHODIMP
  97 nsArray::Enumerate(nsISimpleEnumerator **aResult)
  98 {
  99     return NS_NewArrayEnumerator(aResult, static_cast<nsIArray*>(this));
 100 }
 101
 102 // nsIMutableArray implementation
 103
 104 NS_IMETHODIMP
 105 nsArray::AppendElement(nsISupports* aElement, bool aWeak)
 106 {
 107     bool result;
 108     if (aWeak) {
 109         nsCOMPtr<nsIWeakReference> elementRef = do_GetWeakReference(aElement);
 110         NS_ASSERTION(elementRef, "AppendElement: Trying to use weak references on an object that doesn't support it");
 111         if (!elementRef)
 112             return NS_ERROR_FAILURE;
 113         result = mArray.AppendObject(elementRef);
 114     }
 115
 116     else {
 117         // add the object directly
 118         result = mArray.AppendObject(aElement);
 119     }
 120     return result ? NS_OK : NS_ERROR_FAILURE;
 121 }
 122
 123 NS_IMETHODIMP
 124 nsArray::RemoveElementAt(uint32_t aIndex)
 125 {
 126     bool result = mArray.RemoveObjectAt(aIndex);
 127     return result ? NS_OK : NS_ERROR_FAILURE;
 128 }
 129
 130 NS_IMETHODIMP
 131 nsArray::InsertElementAt(nsISupports* aElement, uint32_t aIndex, bool aWeak)
 132 {
 133     nsCOMPtr<nsISupports> elementRef;
 134     if (aWeak) {
 135         elementRef = do_GetWeakReference(aElement);
 136         NS_ASSERTION(elementRef, "InsertElementAt: Trying to use weak references on an object that doesn't support it");
 137         if (!elementRef)
 138             return NS_ERROR_FAILURE;
 139     } else {
 140         elementRef = aElement;
 141     }
 142     bool result = mArray.InsertObjectAt(elementRef, aIndex);
 143     return result ? NS_OK : NS_ERROR_FAILURE;
 144 }
 145
 146 NS_IMETHODIMP
 147 nsArray::ReplaceElementAt(nsISupports* aElement, uint32_t aIndex, bool aWeak)
 148 {
 149     nsCOMPtr<nsISupports> elementRef;
 150     if (aWeak) {
 151         elementRef = do_GetWeakReference(aElement);
 152         NS_ASSERTION(elementRef, "ReplaceElementAt: Trying to use weak references on an object that doesn't support it");
 153         if (!elementRef)
 154             return NS_ERROR_FAILURE;
 155     } else {
 156         elementRef = aElement;
 157     }
 158     bool result = mArray.ReplaceObjectAt(elementRef, aIndex);
 159     return result ? NS_OK : NS_ERROR_FAILURE;
 160 }
 161
 162 NS_IMETHODIMP
 163 nsArray::Clear()
 164 {
 165     mArray.Clear();
 166     return NS_OK;
 167 }
 168
 169 //
 170 // static helper routines
 171 //
 172 bool
 173 FindElementCallback(void *aElement, void* aClosure)
 174 {
 175     findIndexOfClosure* closure =
 176         static_cast<findIndexOfClosure*>(aClosure);
 177
 178     nsISupports* element =
 179         static_cast<nsISupports*>(aElement);
 180
 181     // don't start searching until we're past the startIndex
 182     if (closure->resultIndex >= closure->startIndex &&
 183         element == closure->targetElement) {
 184         return false;    // stop! We found it
 185     }
 186     closure->resultIndex++;
 187
 188     return true;
 189 }
 190
 191 nsresult
 192 nsArray::XPCOMConstructor(nsISupports *aOuter, const nsIID& aIID, void **aResult)
 193 {
 194     if (aOuter)
 195         return NS_ERROR_NO_AGGREGATION;
 196
 197     nsCOMPtr<nsIMutableArray> inst = Create();
 198     return inst->QueryInterface(aIID, aResult);
 199 }
 200
 201 already_AddRefed<nsIMutableArray>
 202 nsArray::Create()
 203 {
 204     nsCOMPtr<nsIMutableArray> inst = NS_IsMainThread() ? new nsArrayCC : new nsArray;
 205     return inst.forget();
 206 }