dom/base/nsDOMAttributeMap.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /*
   7  * Implementation of the |attributes| property of DOM Core's Element object.
   8  */
   9
  10 #ifndef nsDOMAttributeMap_h
  11 #define nsDOMAttributeMap_h
  12
  13 #include "mozilla/MemoryReporting.h"
  14 #include "mozilla/UniquePtr.h"
  15 #include "mozilla/dom/Attr.h"
  16 #include "mozilla/ErrorResult.h"
  17 #include "nsCycleCollectionParticipant.h"
  18 #include "nsIDOMMozNamedAttrMap.h"
  19 #include "nsRefPtrHashtable.h"
  20 #include "nsString.h"
  21 #include "nsWrapperCache.h"
  22
  23 class nsIAtom;
  24 class nsIDocument;
  25
  26 /**
  27  * Structure used as a key for caching Attrs in nsDOMAttributeMap's mAttributeCache.
  28  */
  29 class nsAttrKey
  30 {
  31 public:
  32   /**
  33    * The namespace of the attribute
  34    */
  35   int32_t  mNamespaceID;
  36
  37   /**
  38    * The atom for attribute, weak ref. is fine as we only use it for the
  39    * hashcode, we never dereference it.
  40    */
  41   nsIAtom* mLocalName;
  42
  43   nsAttrKey(int32_t aNs, nsIAtom* aName)
  44     : mNamespaceID(aNs), mLocalName(aName) {}
  45
  46   nsAttrKey(const nsAttrKey& aAttr)
  47     : mNamespaceID(aAttr.mNamespaceID), mLocalName(aAttr.mLocalName) {}
  48 };
  49
  50 /**
  51  * PLDHashEntryHdr implementation for nsAttrKey.
  52  */
  53 class nsAttrHashKey : public PLDHashEntryHdr
  54 {
  55 public:
  56   typedef const nsAttrKey& KeyType;
  57   typedef const nsAttrKey* KeyTypePointer;
  58
  59   explicit nsAttrHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
  60   nsAttrHashKey(const nsAttrHashKey& aCopy) : mKey(aCopy.mKey) {}
  61   ~nsAttrHashKey() {}
  62
  63   KeyType GetKey() const { return mKey; }
  64   bool KeyEquals(KeyTypePointer aKey) const
  65     {
  66       return mKey.mLocalName == aKey->mLocalName &&
  67              mKey.mNamespaceID == aKey->mNamespaceID;
  68     }
  69
  70   static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
  71   static PLDHashNumber HashKey(KeyTypePointer aKey)
  72     {
  73       if (!aKey)
  74         return 0;
  75
  76       return mozilla::HashGeneric(aKey->mNamespaceID, aKey->mLocalName);
  77     }
  78   enum { ALLOW_MEMMOVE = true };
  79
  80 private:
  81   nsAttrKey mKey;
  82 };
  83
  84 // Helper class that implements the nsIDOMMozNamedAttrMap interface.
  85 class nsDOMAttributeMap : public nsIDOMMozNamedAttrMap
  86                         , public nsWrapperCache
  87 {
  88 public:
  89   typedef mozilla::dom::Attr Attr;
  90   typedef mozilla::dom::Element Element;
  91   typedef mozilla::ErrorResult ErrorResult;
  92
  93   explicit nsDOMAttributeMap(Element *aContent);
  94
  95   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  96   NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS(nsDOMAttributeMap)
  97
  98   // nsIDOMMozNamedAttrMap interface
  99   NS_DECL_NSIDOMMOZNAMEDATTRMAP
 100
 101   void DropReference();
 102
 103   Element* GetContent()
 104   {
 105     return mContent;
 106   }
 107
 108   /**
 109    * Called when mContent is moved into a new document.
 110    * Updates the nodeinfos of all owned nodes.
 111    */
 112   nsresult SetOwnerDocument(nsIDocument* aDocument);
 113
 114   /**
 115    * Drop an attribute from the map's cache (does not remove the attribute
 116    * from the node!)
 117    */
 118   void DropAttribute(int32_t aNamespaceID, nsIAtom* aLocalName);
 119
 120   /**
 121    * Returns the number of attribute nodes currently in the map.
 122    * Note: this is just the number of cached attribute nodes, not the number of
 123    * attributes in mContent.
 124    *
 125    * @return The number of attribute nodes in the map.
 126    */
 127   uint32_t Count() const;
 128
 129   typedef nsRefPtrHashtable<nsAttrHashKey, Attr> AttrCache;
 130
 131   /**
 132    * Enumerates over the attribute nodess in the map and calls aFunc for each
 133    * one. If aFunc returns PL_DHASH_STOP we'll stop enumerating at that point.
 134    *
 135    * @return The number of attribute nodes that aFunc was called for.
 136    */
 137   uint32_t Enumerate(AttrCache::EnumReadFunction aFunc, void *aUserArg) const;
 138
 139   Element* GetParentObject() const
 140   {
 141     return mContent;
 142   }
 143   virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
 144
 145   // WebIDL
 146   Attr* GetNamedItem(const nsAString& aAttrName);
 147   Attr* NamedGetter(const nsAString& aAttrName, bool& aFound);
 148   bool NameIsEnumerable(const nsAString& aName);
 149   already_AddRefed<Attr>
 150   SetNamedItem(Attr& aAttr, ErrorResult& aError)
 151   {
 152     return SetNamedItemInternal(aAttr, false, aError);
 153   }
 154   already_AddRefed<Attr>
 155   RemoveNamedItem(const nsAString& aName, ErrorResult& aError);
 156
 157   Attr* Item(uint32_t aIndex);
 158   Attr* IndexedGetter(uint32_t aIndex, bool& aFound);
 159   uint32_t Length() const;
 160
 161   Attr*
 162   GetNamedItemNS(const nsAString& aNamespaceURI,
 163                  const nsAString& aLocalName);
 164   already_AddRefed<Attr>
 165   SetNamedItemNS(Attr& aNode, ErrorResult& aError)
 166   {
 167     return SetNamedItemInternal(aNode, true, aError);
 168   }
 169   already_AddRefed<Attr>
 170   RemoveNamedItemNS(const nsAString& aNamespaceURI, const nsAString& aLocalName,
 171                     ErrorResult& aError);
 172
 173   void GetSupportedNames(unsigned, nsTArray<nsString>& aNames)
 174   {
 175     // No supported names we want to show up in iteration.
 176   }
 177
 178   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 179
 180 protected:
 181   virtual ~nsDOMAttributeMap();
 182
 183 private:
 184   nsCOMPtr<Element> mContent;
 185
 186   /**
 187    * Cache of Attrs. It's usually empty, and thus initialized lazily.
 188    */
 189   mozilla::UniquePtr<AttrCache> mAttributeCache;
 190
 191   void EnsureAttributeCache();
 192
 193   /**
 194    * SetNamedItem() (aWithNS = false) and SetNamedItemNS() (aWithNS =
 195    * true) implementation.
 196    */
 197   already_AddRefed<Attr>
 198   SetNamedItemInternal(Attr& aNode, bool aWithNS, ErrorResult& aError);
 199
 200   already_AddRefed<mozilla::dom::NodeInfo>
 201   GetAttrNodeInfo(const nsAString& aNamespaceURI,
 202                   const nsAString& aLocalName);
 203
 204   Attr* GetAttribute(mozilla::dom::NodeInfo* aNodeInfo, bool aNsAware);
 205
 206   /**
 207    * Remove an attribute, returns the removed node.
 208    */
 209   already_AddRefed<Attr> RemoveAttribute(mozilla::dom::NodeInfo* aNodeInfo);
 210 };
 211
 212 // XXX khuey yes this is crazy.  The bindings code needs to see this include,
 213 // but if we pull it in at the top of the file we get a circular include
 214 // problem.
 215 #include "mozilla/dom/Element.h"
 216
 217 #endif /* nsDOMAttributeMap_h */