xpcom/glue/nsEnumeratorUtils.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 "mozilla/Attributes.h"
   8
   9 #include "nsEnumeratorUtils.h"
  10
  11 #include "nsISimpleEnumerator.h"
  12 #include "nsIStringEnumerator.h"
  13
  14 #include "nsCOMPtr.h"
  15
  16 class EmptyEnumeratorImpl
  17   : public nsISimpleEnumerator
  18   , public nsIUTF8StringEnumerator
  19   , public nsIStringEnumerator
  20 {
  21 public:
  22   EmptyEnumeratorImpl() {}
  23
  24   // nsISupports interface
  25   NS_DECL_ISUPPORTS_INHERITED  // not really inherited, but no mRefCnt
  26
  27   // nsISimpleEnumerator
  28   NS_DECL_NSISIMPLEENUMERATOR
  29   NS_DECL_NSIUTF8STRINGENUMERATOR
  30   // can't use NS_DECL_NSISTRINGENUMERATOR because they share the
  31   // HasMore() signature
  32   NS_IMETHOD GetNext(nsAString& aResult) MOZ_OVERRIDE;
  33
  34   static EmptyEnumeratorImpl* GetInstance()
  35   {
  36     static const EmptyEnumeratorImpl kInstance;
  37     return const_cast<EmptyEnumeratorImpl*>(&kInstance);
  38   }
  39 };
  40
  41 // nsISupports interface
  42 NS_IMETHODIMP_(MozExternalRefCountType)
  43 EmptyEnumeratorImpl::AddRef(void)
  44 {
  45   return 2;
  46 }
  47
  48 NS_IMETHODIMP_(MozExternalRefCountType)
  49 EmptyEnumeratorImpl::Release(void)
  50 {
  51   return 1;
  52 }
  53
  54 NS_IMPL_QUERY_INTERFACE(EmptyEnumeratorImpl, nsISimpleEnumerator,
  55                         nsIUTF8StringEnumerator, nsIStringEnumerator)
  56
  57 // nsISimpleEnumerator interface
  58 NS_IMETHODIMP
  59 EmptyEnumeratorImpl::HasMoreElements(bool* aResult)
  60 {
  61   *aResult = false;
  62   return NS_OK;
  63 }
  64
  65 NS_IMETHODIMP
  66 EmptyEnumeratorImpl::HasMore(bool* aResult)
  67 {
  68   *aResult = false;
  69   return NS_OK;
  70 }
  71
  72 NS_IMETHODIMP
  73 EmptyEnumeratorImpl::GetNext(nsISupports** aResult)
  74 {
  75   return NS_ERROR_UNEXPECTED;
  76 }
  77
  78 NS_IMETHODIMP
  79 EmptyEnumeratorImpl::GetNext(nsACString& aResult)
  80 {
  81   return NS_ERROR_UNEXPECTED;
  82 }
  83
  84 NS_IMETHODIMP
  85 EmptyEnumeratorImpl::GetNext(nsAString& aResult)
  86 {
  87   return NS_ERROR_UNEXPECTED;
  88 }
  89
  90 nsresult
  91 NS_NewEmptyEnumerator(nsISimpleEnumerator** aResult)
  92 {
  93   *aResult = EmptyEnumeratorImpl::GetInstance();
  94   return NS_OK;
  95 }
  96
  97 ////////////////////////////////////////////////////////////////////////////////
  98
  99 class nsSingletonEnumerator MOZ_FINAL : public nsISimpleEnumerator
 100 {
 101 public:
 102   NS_DECL_ISUPPORTS
 103
 104   // nsISimpleEnumerator methods
 105   NS_IMETHOD HasMoreElements(bool* aResult) MOZ_OVERRIDE;
 106   NS_IMETHOD GetNext(nsISupports** aResult) MOZ_OVERRIDE;
 107
 108   explicit nsSingletonEnumerator(nsISupports* aValue);
 109
 110 private:
 111   ~nsSingletonEnumerator();
 112
 113 protected:
 114   nsCOMPtr<nsISupports> mValue;
 115   bool mConsumed;
 116 };
 117
 118 nsSingletonEnumerator::nsSingletonEnumerator(nsISupports* aValue)
 119   : mValue(aValue)
 120 {
 121   mConsumed = (mValue ? false : true);
 122 }
 123
 124 nsSingletonEnumerator::~nsSingletonEnumerator()
 125 {
 126 }
 127
 128 NS_IMPL_ISUPPORTS(nsSingletonEnumerator, nsISimpleEnumerator)
 129
 130 NS_IMETHODIMP
 131 nsSingletonEnumerator::HasMoreElements(bool* aResult)
 132 {
 133   NS_PRECONDITION(aResult != 0, "null ptr");
 134   if (!aResult) {
 135     return NS_ERROR_NULL_POINTER;
 136   }
 137
 138   *aResult = !mConsumed;
 139   return NS_OK;
 140 }
 141
 142
 143 NS_IMETHODIMP
 144 nsSingletonEnumerator::GetNext(nsISupports** aResult)
 145 {
 146   NS_PRECONDITION(aResult != 0, "null ptr");
 147   if (!aResult) {
 148     return NS_ERROR_NULL_POINTER;
 149   }
 150
 151   if (mConsumed) {
 152     return NS_ERROR_UNEXPECTED;
 153   }
 154
 155   mConsumed = true;
 156
 157   *aResult = mValue;
 158   NS_ADDREF(*aResult);
 159   return NS_OK;
 160 }
 161
 162 nsresult
 163 NS_NewSingletonEnumerator(nsISimpleEnumerator** aResult,
 164                           nsISupports* aSingleton)
 165 {
 166   nsSingletonEnumerator* enumer = new nsSingletonEnumerator(aSingleton);
 167   if (!enumer) {
 168     return NS_ERROR_OUT_OF_MEMORY;
 169   }
 170   *aResult = enumer;
 171   NS_ADDREF(*aResult);
 172   return NS_OK;
 173 }
 174
 175 ////////////////////////////////////////////////////////////////////////////////
 176
 177 class nsUnionEnumerator MOZ_FINAL : public nsISimpleEnumerator
 178 {
 179 public:
 180   NS_DECL_ISUPPORTS
 181
 182   // nsISimpleEnumerator methods
 183   NS_IMETHOD HasMoreElements(bool* aResult) MOZ_OVERRIDE;
 184   NS_IMETHOD GetNext(nsISupports** aResult) MOZ_OVERRIDE;
 185
 186   nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
 187                     nsISimpleEnumerator* aSecondEnumerator);
 188
 189 private:
 190   ~nsUnionEnumerator();
 191
 192 protected:
 193   nsCOMPtr<nsISimpleEnumerator> mFirstEnumerator, mSecondEnumerator;
 194   bool mConsumed;
 195   bool mAtSecond;
 196 };
 197
 198 nsUnionEnumerator::nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
 199                                      nsISimpleEnumerator* aSecondEnumerator)
 200   : mFirstEnumerator(aFirstEnumerator)
 201   , mSecondEnumerator(aSecondEnumerator)
 202   , mConsumed(false)
 203   , mAtSecond(false)
 204 {
 205 }
 206
 207 nsUnionEnumerator::~nsUnionEnumerator()
 208 {
 209 }
 210
 211 NS_IMPL_ISUPPORTS(nsUnionEnumerator, nsISimpleEnumerator)
 212
 213 NS_IMETHODIMP
 214 nsUnionEnumerator::HasMoreElements(bool* aResult)
 215 {
 216   NS_PRECONDITION(aResult != 0, "null ptr");
 217   if (!aResult) {
 218     return NS_ERROR_NULL_POINTER;
 219   }
 220
 221   nsresult rv;
 222
 223   if (mConsumed) {
 224     *aResult = false;
 225     return NS_OK;
 226   }
 227
 228   if (!mAtSecond) {
 229     rv = mFirstEnumerator->HasMoreElements(aResult);
 230     if (NS_FAILED(rv)) {
 231       return rv;
 232     }
 233
 234     if (*aResult) {
 235       return NS_OK;
 236     }
 237
 238     mAtSecond = true;
 239   }
 240
 241   rv = mSecondEnumerator->HasMoreElements(aResult);
 242   if (NS_FAILED(rv)) {
 243     return rv;
 244   }
 245
 246   if (*aResult) {
 247     return NS_OK;
 248   }
 249
 250   *aResult = false;
 251   mConsumed = true;
 252   return NS_OK;
 253 }
 254
 255 NS_IMETHODIMP
 256 nsUnionEnumerator::GetNext(nsISupports** aResult)
 257 {
 258   NS_PRECONDITION(aResult != 0, "null ptr");
 259   if (!aResult) {
 260     return NS_ERROR_NULL_POINTER;
 261   }
 262
 263   if (mConsumed) {
 264     return NS_ERROR_UNEXPECTED;
 265   }
 266
 267   if (!mAtSecond) {
 268     return mFirstEnumerator->GetNext(aResult);
 269   }
 270
 271   return mSecondEnumerator->GetNext(aResult);
 272 }
 273
 274 nsresult
 275 NS_NewUnionEnumerator(nsISimpleEnumerator** aResult,
 276                       nsISimpleEnumerator* aFirstEnumerator,
 277                       nsISimpleEnumerator* aSecondEnumerator)
 278 {
 279   *aResult = nullptr;
 280   if (!aFirstEnumerator) {
 281     *aResult = aSecondEnumerator;
 282   } else if (!aSecondEnumerator) {
 283     *aResult = aFirstEnumerator;
 284   } else {
 285     nsUnionEnumerator* enumer = new nsUnionEnumerator(aFirstEnumerator,
 286                                                       aSecondEnumerator);
 287     if (!enumer) {
 288       return NS_ERROR_OUT_OF_MEMORY;
 289     }
 290     *aResult = enumer;
 291   }
 292   NS_ADDREF(*aResult);
 293   return NS_OK;
 294 }