xpcom/ds/nsHashPropertyBag.cpp

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