xpcom/ds/nsHashPropertyBag.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 "nsHashPropertyBag.h"
   8 #include "nsArray.h"
   9 #include "nsArrayEnumerator.h"
  10 #include "nsIVariant.h"
  11 #include "nsIProperty.h"
  12 #include "nsVariant.h"
  13 #include "mozilla/Attributes.h"
  14
  15 /*
  16  * nsHashPropertyBagBase implementation.
  17  */
  18
  19 NS_IMETHODIMP
  20 nsHashPropertyBagBase::HasKey(const nsAString& aName, bool* aResult)
  21 {
  22   *aResult = mPropertyHash.Get(aName, nullptr);
  23   return NS_OK;
  24 }
  25
  26 NS_IMETHODIMP
  27 nsHashPropertyBagBase::Get(const nsAString& aName, nsIVariant** aResult)
  28 {
  29   if (!mPropertyHash.Get(aName, aResult)) {
  30     *aResult = nullptr;
  31   }
  32
  33   return NS_OK;
  34 }
  35
  36 NS_IMETHODIMP
  37 nsHashPropertyBagBase::GetProperty(const nsAString& aName, nsIVariant** aResult)
  38 {
  39   bool isFound = mPropertyHash.Get(aName, aResult);
  40   if (!isFound) {
  41     return NS_ERROR_FAILURE;
  42   }
  43
  44   return NS_OK;
  45 }
  46
  47 NS_IMETHODIMP
  48 nsHashPropertyBagBase::SetProperty(const nsAString& aName, nsIVariant* aValue)
  49 {
  50   if (NS_WARN_IF(!aValue)) {
  51     return NS_ERROR_INVALID_ARG;
  52   }
  53
  54   mPropertyHash.Put(aName, aValue);
  55
  56   return NS_OK;
  57 }
  58
  59 NS_IMETHODIMP
  60 nsHashPropertyBagBase::DeleteProperty(const nsAString& aName)
  61 {
  62   // is it too much to ask for ns*Hashtable to return
  63   // a boolean indicating whether RemoveEntry succeeded
  64   // or not?!?!
  65   bool isFound = mPropertyHash.Get(aName, nullptr);
  66   if (!isFound) {
  67     return NS_ERROR_FAILURE;
  68   }
  69
  70   // then from the hash
  71   mPropertyHash.Remove(aName);
  72
  73   return NS_OK;
  74 }
  75
  76
  77 //
  78 // nsSimpleProperty class and impl; used for GetEnumerator
  79 //
  80
  81 class nsSimpleProperty MOZ_FINAL : public nsIProperty
  82 {
  83   ~nsSimpleProperty() {}
  84
  85 public:
  86   nsSimpleProperty(const nsAString& aName, nsIVariant* aValue)
  87     : mName(aName)
  88     , mValue(aValue)
  89   {
  90   }
  91
  92   NS_DECL_ISUPPORTS
  93   NS_DECL_NSIPROPERTY
  94 protected:
  95   nsString mName;
  96   nsCOMPtr<nsIVariant> mValue;
  97 };
  98
  99 NS_IMPL_ISUPPORTS(nsSimpleProperty, nsIProperty)
 100
 101 NS_IMETHODIMP
 102 nsSimpleProperty::GetName(nsAString& aName)
 103 {
 104   aName.Assign(mName);
 105   return NS_OK;
 106 }
 107
 108 NS_IMETHODIMP
 109 nsSimpleProperty::GetValue(nsIVariant** aValue)
 110 {
 111   NS_IF_ADDREF(*aValue = mValue);
 112   return NS_OK;
 113 }
 114
 115 // end nsSimpleProperty
 116
 117 static PLDHashOperator
 118 PropertyHashToArrayFunc(const nsAString& aKey,
 119                         nsIVariant* aData,
 120                         void* aUserArg)
 121 {
 122   nsIMutableArray* propertyArray = static_cast<nsIMutableArray*>(aUserArg);
 123   nsSimpleProperty* sprop = new nsSimpleProperty(aKey, aData);
 124   propertyArray->AppendElement(sprop, false);
 125   return PL_DHASH_NEXT;
 126 }
 127
 128
 129 NS_IMETHODIMP
 130 nsHashPropertyBagBase::GetEnumerator(nsISimpleEnumerator** aResult)
 131 {
 132   nsCOMPtr<nsIMutableArray> propertyArray = nsArray::Create();
 133   if (!propertyArray) {
 134     return NS_ERROR_OUT_OF_MEMORY;
 135   }
 136
 137   mPropertyHash.EnumerateRead(PropertyHashToArrayFunc, propertyArray.get());
 138
 139   return NS_NewArrayEnumerator(aResult, propertyArray);
 140 }
 141
 142 #define IMPL_GETSETPROPERTY_AS(Name, Type) \
 143 NS_IMETHODIMP \
 144 nsHashPropertyBagBase::GetPropertyAs ## Name (const nsAString & prop, Type *_retval) \
 145 { \
 146     nsIVariant* v = mPropertyHash.GetWeak(prop); \
 147     if (!v) \
 148         return NS_ERROR_NOT_AVAILABLE; \
 149     return v->GetAs ## Name(_retval); \
 150 } \
 151 \
 152 NS_IMETHODIMP \
 153 nsHashPropertyBagBase::SetPropertyAs ## Name (const nsAString & prop, Type value) \
 154 { \
 155     nsCOMPtr<nsIWritableVariant> var = new nsVariant(); \
 156     var->SetAs ## Name(value); \
 157     return SetProperty(prop, var); \
 158 }
 159
 160 IMPL_GETSETPROPERTY_AS(Int32, int32_t)
 161 IMPL_GETSETPROPERTY_AS(Uint32, uint32_t)
 162 IMPL_GETSETPROPERTY_AS(Int64, int64_t)
 163 IMPL_GETSETPROPERTY_AS(Uint64, uint64_t)
 164 IMPL_GETSETPROPERTY_AS(Double, double)
 165 IMPL_GETSETPROPERTY_AS(Bool, bool)
 166
 167
 168 NS_IMETHODIMP
 169 nsHashPropertyBagBase::GetPropertyAsAString(const nsAString& aProp,
 170                                         nsAString& aResult)
 171 {
 172   nsIVariant* v = mPropertyHash.GetWeak(aProp);
 173   if (!v) {
 174     return NS_ERROR_NOT_AVAILABLE;
 175   }
 176   return v->GetAsAString(aResult);
 177 }
 178
 179 NS_IMETHODIMP
 180 nsHashPropertyBagBase::GetPropertyAsACString(const nsAString& aProp,
 181                                          nsACString& aResult)
 182 {
 183   nsIVariant* v = mPropertyHash.GetWeak(aProp);
 184   if (!v) {
 185     return NS_ERROR_NOT_AVAILABLE;
 186   }
 187   return v->GetAsACString(aResult);
 188 }
 189
 190 NS_IMETHODIMP
 191 nsHashPropertyBagBase::GetPropertyAsAUTF8String(const nsAString& aProp,
 192                                             nsACString& aResult)
 193 {
 194   nsIVariant* v = mPropertyHash.GetWeak(aProp);
 195   if (!v) {
 196     return NS_ERROR_NOT_AVAILABLE;
 197   }
 198   return v->GetAsAUTF8String(aResult);
 199 }
 200
 201 NS_IMETHODIMP
 202 nsHashPropertyBagBase::GetPropertyAsInterface(const nsAString& aProp,
 203                                           const nsIID& aIID,
 204                                           void** aResult)
 205 {
 206   nsIVariant* v = mPropertyHash.GetWeak(aProp);
 207   if (!v) {
 208     return NS_ERROR_NOT_AVAILABLE;
 209   }
 210   nsCOMPtr<nsISupports> val;
 211   nsresult rv = v->GetAsISupports(getter_AddRefs(val));
 212   if (NS_FAILED(rv)) {
 213     return rv;
 214   }
 215   if (!val) {
 216     // We have a value, but it's null
 217     *aResult = nullptr;
 218     return NS_OK;
 219   }
 220   return val->QueryInterface(aIID, aResult);
 221 }
 222
 223 NS_IMETHODIMP
 224 nsHashPropertyBagBase::SetPropertyAsAString(const nsAString& aProp,
 225                                         const nsAString& aValue)
 226 {
 227   nsCOMPtr<nsIWritableVariant> var = new nsVariant();
 228   var->SetAsAString(aValue);
 229   return SetProperty(aProp, var);
 230 }
 231
 232 NS_IMETHODIMP
 233 nsHashPropertyBagBase::SetPropertyAsACString(const nsAString& aProp,
 234                                          const nsACString& aValue)
 235 {
 236   nsCOMPtr<nsIWritableVariant> var = new nsVariant();
 237   var->SetAsACString(aValue);
 238   return SetProperty(aProp, var);
 239 }
 240
 241 NS_IMETHODIMP
 242 nsHashPropertyBagBase::SetPropertyAsAUTF8String(const nsAString& aProp,
 243                                             const nsACString& aValue)
 244 {
 245   nsCOMPtr<nsIWritableVariant> var = new nsVariant();
 246   var->SetAsAUTF8String(aValue);
 247   return SetProperty(aProp, var);
 248 }
 249
 250 NS_IMETHODIMP
 251 nsHashPropertyBagBase::SetPropertyAsInterface(const nsAString& aProp,
 252                                           nsISupports* aValue)
 253 {
 254   nsCOMPtr<nsIWritableVariant> var = new nsVariant();
 255   var->SetAsISupports(aValue);
 256   return SetProperty(aProp, var);
 257 }
 258
 259
 260 /*
 261  * nsHashPropertyBag implementation.
 262  */
 263
 264 NS_IMPL_ADDREF(nsHashPropertyBag)
 265 NS_IMPL_RELEASE(nsHashPropertyBag)
 266
 267 NS_INTERFACE_MAP_BEGIN(nsHashPropertyBag)
 268   NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag)
 269   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIPropertyBag, nsIWritablePropertyBag)
 270   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWritablePropertyBag)
 271   NS_INTERFACE_MAP_ENTRY(nsIPropertyBag2)
 272   NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag2)
 273 NS_INTERFACE_MAP_END
 274
 275
 276 /*
 277  * nsHashPropertyBagCC implementation.
 278  */
 279
 280 NS_IMPL_CYCLE_COLLECTION(nsHashPropertyBagCC, mPropertyHash)
 281
 282 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsHashPropertyBagCC)
 283 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsHashPropertyBagCC)
 284
 285 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsHashPropertyBagCC)
 286   NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag)
 287   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIPropertyBag, nsIWritablePropertyBag)
 288   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWritablePropertyBag)
 289   NS_INTERFACE_MAP_ENTRY(nsIPropertyBag2)
 290   NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag2)
 291 NS_INTERFACE_MAP_END