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);
  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);
 106   NS_IMETHOD GetNext(nsISupports** aResult);
 107
 108   explicit nsSingletonEnumerator(nsISupports* aValue);
 109
 110 private:
 111   ~nsSingletonEnumerator();
 112
 113 protected:
 114   nsISupports* mValue;
 115   bool mConsumed;
 116 };
 117
 118 nsSingletonEnumerator::nsSingletonEnumerator(nsISupports* aValue)
 119   : mValue(aValue)
 120 {
 121   NS_IF_ADDREF(mValue);
 122   mConsumed = (mValue ? false : true);
 123 }
 124
 125 nsSingletonEnumerator::~nsSingletonEnumerator()
 126 {
 127   NS_IF_RELEASE(mValue);
 128 }
 129
 130 NS_IMPL_ISUPPORTS(nsSingletonEnumerator, nsISimpleEnumerator)
 131
 132 NS_IMETHODIMP
 133 nsSingletonEnumerator::HasMoreElements(bool* aResult)
 134 {
 135   NS_PRECONDITION(aResult != 0, "null ptr");
 136   if (!aResult) {
 137     return NS_ERROR_NULL_POINTER;
 138   }
 139
 140   *aResult = !mConsumed;
 141   return NS_OK;
 142 }
 143
 144
 145 NS_IMETHODIMP
 146 nsSingletonEnumerator::GetNext(nsISupports** aResult)
 147 {
 148   NS_PRECONDITION(aResult != 0, "null ptr");
 149   if (!aResult) {
 150     return NS_ERROR_NULL_POINTER;
 151   }
 152
 153   if (mConsumed) {
 154     return NS_ERROR_UNEXPECTED;
 155   }
 156
 157   mConsumed = true;
 158
 159   *aResult = mValue;
 160   NS_ADDREF(*aResult);
 161   return NS_OK;
 162 }
 163
 164 nsresult
 165 NS_NewSingletonEnumerator(nsISimpleEnumerator** aResult,
 166                           nsISupports* aSingleton)
 167 {
 168   nsSingletonEnumerator* enumer = new nsSingletonEnumerator(aSingleton);
 169   if (!enumer) {
 170     return NS_ERROR_OUT_OF_MEMORY;
 171   }
 172   *aResult = enumer;
 173   NS_ADDREF(*aResult);
 174   return NS_OK;
 175 }
 176
 177 ////////////////////////////////////////////////////////////////////////////////
 178
 179 class nsUnionEnumerator MOZ_FINAL : public nsISimpleEnumerator
 180 {
 181 public:
 182   NS_DECL_ISUPPORTS
 183
 184   // nsISimpleEnumerator methods
 185   NS_IMETHOD HasMoreElements(bool* aResult);
 186   NS_IMETHOD GetNext(nsISupports** aResult);
 187
 188   nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
 189                     nsISimpleEnumerator* aSecondEnumerator);
 190
 191 private:
 192   ~nsUnionEnumerator();
 193
 194 protected:
 195   nsCOMPtr<nsISimpleEnumerator> mFirstEnumerator, mSecondEnumerator;
 196   bool mConsumed;
 197   bool mAtSecond;
 198 };
 199
 200 nsUnionEnumerator::nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
 201                                      nsISimpleEnumerator* aSecondEnumerator)
 202   : mFirstEnumerator(aFirstEnumerator)
 203   , mSecondEnumerator(aSecondEnumerator)
 204   , mConsumed(false)
 205   , mAtSecond(false)
 206 {
 207 }
 208
 209 nsUnionEnumerator::~nsUnionEnumerator()
 210 {
 211 }
 212
 213 NS_IMPL_ISUPPORTS(nsUnionEnumerator, nsISimpleEnumerator)
 214
 215 NS_IMETHODIMP
 216 nsUnionEnumerator::HasMoreElements(bool* aResult)
 217 {
 218   NS_PRECONDITION(aResult != 0, "null ptr");
 219   if (!aResult) {
 220     return NS_ERROR_NULL_POINTER;
 221   }
 222
 223   nsresult rv;
 224
 225   if (mConsumed) {
 226     *aResult = false;
 227     return NS_OK;
 228   }
 229
 230   if (!mAtSecond) {
 231     rv = mFirstEnumerator->HasMoreElements(aResult);
 232     if (NS_FAILED(rv)) {
 233       return rv;
 234     }
 235
 236     if (*aResult) {
 237       return NS_OK;
 238     }
 239
 240     mAtSecond = true;
 241   }
 242
 243   rv = mSecondEnumerator->HasMoreElements(aResult);
 244   if (NS_FAILED(rv)) {
 245     return rv;
 246   }
 247
 248   if (*aResult) {
 249     return NS_OK;
 250   }
 251
 252   *aResult = false;
 253   mConsumed = true;
 254   return NS_OK;
 255 }
 256
 257 NS_IMETHODIMP
 258 nsUnionEnumerator::GetNext(nsISupports** aResult)
 259 {
 260   NS_PRECONDITION(aResult != 0, "null ptr");
 261   if (!aResult) {
 262     return NS_ERROR_NULL_POINTER;
 263   }
 264
 265   if (mConsumed) {
 266     return NS_ERROR_UNEXPECTED;
 267   }
 268
 269   if (!mAtSecond) {
 270     return mFirstEnumerator->GetNext(aResult);
 271   }
 272
 273   return mSecondEnumerator->GetNext(aResult);
 274 }
 275
 276 nsresult
 277 NS_NewUnionEnumerator(nsISimpleEnumerator** aResult,
 278                       nsISimpleEnumerator* aFirstEnumerator,
 279                       nsISimpleEnumerator* aSecondEnumerator)
 280 {
 281   *aResult = nullptr;
 282   if (!aFirstEnumerator) {
 283     *aResult = aSecondEnumerator;
 284   } else if (!aSecondEnumerator) {
 285     *aResult = aFirstEnumerator;
 286   } else {
 287     nsUnionEnumerator* enumer = new nsUnionEnumerator(aFirstEnumerator,
 288                                                       aSecondEnumerator);
 289     if (!enumer) {
 290       return NS_ERROR_OUT_OF_MEMORY;
 291     }
 292     *aResult = enumer;
 293   }
 294   NS_ADDREF(*aResult);
 295   return NS_OK;
 296 }