xpcom/ds/nsStringEnumerator.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsStringEnumerator.h"
   8 #include "nsSimpleEnumerator.h"
   9 #include "nsSupportsPrimitives.h"
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/ResultExtensions.h"
  12 #include "mozilla/Try.h"
  13 #include "mozilla/dom/IteratorResultBinding.h"
  14 #include "mozilla/dom/RootedDictionary.h"
  15 #include "mozilla/dom/ToJSValue.h"
  16 #include "nsTArray.h"
  17
  18 using namespace mozilla;
  19 using namespace mozilla::dom;
  20
  21 namespace {
  22
  23 class JSStringEnumerator final : public nsIJSEnumerator {
  24   NS_DECL_ISUPPORTS
  25   NS_DECL_NSIJSENUMERATOR
  26
  27   explicit JSStringEnumerator(nsIStringEnumerator* aEnumerator)
  28       : mEnumerator(aEnumerator) {
  29     MOZ_ASSERT(mEnumerator);
  30   }
  31
  32  private:
  33   ~JSStringEnumerator() = default;
  34
  35   nsCOMPtr<nsIStringEnumerator> mEnumerator;
  36 };
  37
  38 }  // anonymous namespace
  39
  40 nsresult JSStringEnumerator::Iterator(nsIJSEnumerator** aResult) {
  41   RefPtr<JSStringEnumerator> result(this);
  42   result.forget(aResult);
  43   return NS_OK;
  44 }
  45
  46 nsresult JSStringEnumerator::Next(JSContext* aCx,
  47                                   JS::MutableHandleValue aResult) {
  48   RootedDictionary<IteratorResult> result(aCx);
  49
  50   nsAutoString elem;
  51   if (NS_FAILED(mEnumerator->GetNext(elem))) {
  52     result.mDone = true;
  53   } else {
  54     result.mDone = false;
  55
  56     if (!ToJSValue(
  57             aCx, elem,
  58             JS::MutableHandleValue::fromMarkedLocation(&result.mValue))) {
  59       return NS_ERROR_OUT_OF_MEMORY;
  60     }
  61   }
  62
  63   if (!ToJSValue(aCx, result, aResult)) {
  64     return NS_ERROR_OUT_OF_MEMORY;
  65   }
  66   return NS_OK;
  67 }
  68
  69 NS_IMPL_ISUPPORTS(JSStringEnumerator, nsIJSEnumerator)
  70
  71 //
  72 // nsStringEnumeratorBase
  73 //
  74
  75 nsresult nsStringEnumeratorBase::GetNext(nsAString& aResult) {
  76   nsAutoCString str;
  77   MOZ_TRY(GetNext(str));
  78
  79   CopyUTF8toUTF16(str, aResult);
  80   return NS_OK;
  81 }
  82
  83 NS_IMETHODIMP
  84 nsStringEnumeratorBase::StringIterator(nsIJSEnumerator** aRetVal) {
  85   auto result = MakeRefPtr<JSStringEnumerator>(this);
  86   result.forget(aRetVal);
  87   return NS_OK;
  88 }
  89
  90 //
  91 // nsStringEnumerator
  92 //
  93
  94 class nsStringEnumerator final : public nsSimpleEnumerator,
  95                                  public nsIStringEnumerator,
  96                                  public nsIUTF8StringEnumerator {
  97  public:
  98   nsStringEnumerator(const nsTArray<nsString>* aArray, bool aOwnsArray)
  99       : mArray(aArray), mIndex(0), mOwnsArray(aOwnsArray), mIsUnicode(true) {}
 100
 101   nsStringEnumerator(const nsTArray<nsCString>* aArray, bool aOwnsArray)
 102       : mCArray(aArray), mIndex(0), mOwnsArray(aOwnsArray), mIsUnicode(false) {}
 103
 104   nsStringEnumerator(const nsTArray<nsString>* aArray, nsISupports* aOwner)
 105       : mArray(aArray),
 106         mIndex(0),
 107         mOwner(aOwner),
 108         mOwnsArray(false),
 109         mIsUnicode(true) {}
 110
 111   nsStringEnumerator(const nsTArray<nsCString>* aArray, nsISupports* aOwner)
 112       : mCArray(aArray),
 113         mIndex(0),
 114         mOwner(aOwner),
 115         mOwnsArray(false),
 116         mIsUnicode(false) {}
 117
 118   NS_DECL_ISUPPORTS_INHERITED
 119   NS_DECL_NSIUTF8STRINGENUMERATOR
 120   NS_DECL_NSISTRINGENUMERATORBASE
 121
 122   // have to declare nsIStringEnumerator manually, because of
 123   // overlapping method names
 124   NS_IMETHOD GetNext(nsAString& aResult) override;
 125   NS_DECL_NSISIMPLEENUMERATOR
 126
 127   const nsID& DefaultInterface() override {
 128     if (mIsUnicode) {
 129       return NS_GET_IID(nsISupportsString);
 130     }
 131     return NS_GET_IID(nsISupportsCString);
 132   }
 133
 134  private:
 135   ~nsStringEnumerator() {
 136     if (mOwnsArray) {
 137       // const-casting is safe here, because the NS_New*
 138       // constructors make sure mOwnsArray is consistent with
 139       // the constness of the objects
 140       if (mIsUnicode) {
 141         delete const_cast<nsTArray<nsString>*>(mArray);
 142       } else {
 143         delete const_cast<nsTArray<nsCString>*>(mCArray);
 144       }
 145     }
 146   }
 147
 148   union {
 149     const nsTArray<nsString>* mArray;
 150     const nsTArray<nsCString>* mCArray;
 151   };
 152
 153   inline uint32_t Count() {
 154     return mIsUnicode ? mArray->Length() : mCArray->Length();
 155   }
 156
 157   uint32_t mIndex;
 158
 159   // the owner allows us to hold a strong reference to the object
 160   // that owns the array. Having a non-null value in mOwner implies
 161   // that mOwnsArray is false, because we rely on the real owner
 162   // to release the array
 163   nsCOMPtr<nsISupports> mOwner;
 164   bool mOwnsArray;
 165   bool mIsUnicode;
 166 };
 167
 168 NS_IMPL_ISUPPORTS_INHERITED(nsStringEnumerator, nsSimpleEnumerator,
 169                             nsIStringEnumerator, nsIUTF8StringEnumerator)
 170
 171 NS_IMETHODIMP
 172 nsStringEnumerator::HasMore(bool* aResult) {
 173   *aResult = mIndex < Count();
 174   return NS_OK;
 175 }
 176
 177 NS_IMETHODIMP
 178 nsStringEnumerator::HasMoreElements(bool* aResult) { return HasMore(aResult); }
 179
 180 NS_IMETHODIMP
 181 nsStringEnumerator::GetNext(nsISupports** aResult) {
 182   if (mIndex >= mArray->Length()) {
 183     return NS_ERROR_FAILURE;
 184   }
 185
 186   if (mIsUnicode) {
 187     nsSupportsString* stringImpl = new nsSupportsString();
 188
 189     stringImpl->SetData(mArray->ElementAt(mIndex++));
 190     *aResult = stringImpl;
 191   } else {
 192     nsSupportsCString* cstringImpl = new nsSupportsCString();
 193
 194     cstringImpl->SetData(mCArray->ElementAt(mIndex++));
 195     *aResult = cstringImpl;
 196   }
 197   NS_ADDREF(*aResult);
 198   return NS_OK;
 199 }
 200
 201 NS_IMETHODIMP
 202 nsStringEnumerator::GetNext(nsAString& aResult) {
 203   if (NS_WARN_IF(mIndex >= Count())) {
 204     return NS_ERROR_UNEXPECTED;
 205   }
 206
 207   if (mIsUnicode) {
 208     aResult = mArray->ElementAt(mIndex++);
 209   } else {
 210     CopyUTF8toUTF16(mCArray->ElementAt(mIndex++), aResult);
 211   }
 212
 213   return NS_OK;
 214 }
 215
 216 NS_IMETHODIMP
 217 nsStringEnumerator::GetNext(nsACString& aResult) {
 218   if (NS_WARN_IF(mIndex >= Count())) {
 219     return NS_ERROR_UNEXPECTED;
 220   }
 221
 222   if (mIsUnicode) {
 223     CopyUTF16toUTF8(mArray->ElementAt(mIndex++), aResult);
 224   } else {
 225     aResult = mCArray->ElementAt(mIndex++);
 226   }
 227
 228   return NS_OK;
 229 }
 230
 231 NS_IMETHODIMP
 232 nsStringEnumerator::StringIterator(nsIJSEnumerator** aRetVal) {
 233   auto result = MakeRefPtr<JSStringEnumerator>(this);
 234   result.forget(aRetVal);
 235   return NS_OK;
 236 }
 237
 238 template <class T>
 239 static inline nsresult StringEnumeratorTail(T** aResult) {
 240   if (!*aResult) {
 241     return NS_ERROR_OUT_OF_MEMORY;
 242   }
 243   NS_ADDREF(*aResult);
 244   return NS_OK;
 245 }
 246
 247 //
 248 // constructors
 249 //
 250
 251 nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
 252                                 const nsTArray<nsString>* aArray,
 253                                 nsISupports* aOwner) {
 254   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 255     return NS_ERROR_INVALID_ARG;
 256   }
 257
 258   *aResult = new nsStringEnumerator(aArray, aOwner);
 259   return StringEnumeratorTail(aResult);
 260 }
 261
 262 nsresult NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
 263                                     const nsTArray<nsCString>* aArray,
 264                                     nsISupports* aOwner) {
 265   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 266     return NS_ERROR_INVALID_ARG;
 267   }
 268
 269   *aResult = new nsStringEnumerator(aArray, aOwner);
 270   return StringEnumeratorTail(aResult);
 271 }
 272
 273 nsresult NS_NewAdoptingStringEnumerator(nsIStringEnumerator** aResult,
 274                                         nsTArray<nsString>* aArray) {
 275   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 276     return NS_ERROR_INVALID_ARG;
 277   }
 278
 279   *aResult = new nsStringEnumerator(aArray, true);
 280   return StringEnumeratorTail(aResult);
 281 }
 282
 283 nsresult NS_NewAdoptingUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
 284                                             nsTArray<nsCString>* aArray) {
 285   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 286     return NS_ERROR_INVALID_ARG;
 287   }
 288
 289   *aResult = new nsStringEnumerator(aArray, true);
 290   return StringEnumeratorTail(aResult);
 291 }
 292
 293 // const ones internally just forward to the non-const equivalents
 294 nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
 295                                 const nsTArray<nsString>* aArray) {
 296   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 297     return NS_ERROR_INVALID_ARG;
 298   }
 299
 300   *aResult = new nsStringEnumerator(aArray, false);
 301   return StringEnumeratorTail(aResult);
 302 }
 303
 304 nsresult NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
 305                                     const nsTArray<nsCString>* aArray) {
 306   if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
 307     return NS_ERROR_INVALID_ARG;
 308   }
 309
 310   *aResult = new nsStringEnumerator(aArray, false);
 311   return StringEnumeratorTail(aResult);
 312 }