dom/base/nsAttrName.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  * Class that represents the name (nodeinfo or atom) of an attribute;
   8  * using nodeinfos all the time is too slow, so we use atoms when we
   9  * can.
  10  */
  11
  12 #ifndef nsAttrName_h___
  13 #define nsAttrName_h___
  14
  15 #include "mozilla/dom/NodeInfo.h"
  16 #include "nsIAtom.h"
  17 #include "nsDOMString.h"
  18
  19 #define NS_ATTRNAME_NODEINFO_BIT 1
  20 class nsAttrName
  21 {
  22 public:
  23   nsAttrName(const nsAttrName& aOther)
  24     : mBits(aOther.mBits)
  25   {
  26     AddRefInternalName();
  27   }
  28
  29   explicit nsAttrName(nsIAtom* aAtom)
  30     : mBits(reinterpret_cast<uintptr_t>(aAtom))
  31   {
  32     NS_ASSERTION(aAtom, "null atom-name in nsAttrName");
  33     NS_ADDREF(aAtom);
  34   }
  35
  36   explicit nsAttrName(mozilla::dom::NodeInfo* aNodeInfo)
  37   {
  38     NS_ASSERTION(aNodeInfo, "null nodeinfo-name in nsAttrName");
  39     if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
  40       mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
  41       NS_ADDREF(aNodeInfo->NameAtom());
  42     }
  43     else {
  44       mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
  45               NS_ATTRNAME_NODEINFO_BIT;
  46       NS_ADDREF(aNodeInfo);
  47     }
  48   }
  49
  50   ~nsAttrName()
  51   {
  52     ReleaseInternalName();
  53   }
  54
  55   void SetTo(mozilla::dom::NodeInfo* aNodeInfo)
  56   {
  57     NS_ASSERTION(aNodeInfo, "null nodeinfo-name in nsAttrName");
  58
  59     ReleaseInternalName();
  60     if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
  61       mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
  62       NS_ADDREF(aNodeInfo->NameAtom());
  63     }
  64     else {
  65       mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
  66               NS_ATTRNAME_NODEINFO_BIT;
  67       NS_ADDREF(aNodeInfo);
  68     }
  69   }
  70
  71   void SetTo(nsIAtom* aAtom)
  72   {
  73     NS_ASSERTION(aAtom, "null atom-name in nsAttrName");
  74
  75     ReleaseInternalName();
  76     mBits = reinterpret_cast<uintptr_t>(aAtom);
  77     NS_ADDREF(aAtom);
  78   }
  79
  80   bool IsAtom() const
  81   {
  82     return !(mBits & NS_ATTRNAME_NODEINFO_BIT);
  83   }
  84
  85   mozilla::dom::NodeInfo* NodeInfo() const
  86   {
  87     NS_ASSERTION(!IsAtom(), "getting nodeinfo-value of atom-name");
  88     return reinterpret_cast<mozilla::dom::NodeInfo*>(mBits & ~NS_ATTRNAME_NODEINFO_BIT);
  89   }
  90
  91   nsIAtom* Atom() const
  92   {
  93     NS_ASSERTION(IsAtom(), "getting atom-value of nodeinfo-name");
  94     return reinterpret_cast<nsIAtom*>(mBits);
  95   }
  96
  97   bool Equals(const nsAttrName& aOther) const
  98   {
  99     return mBits == aOther.mBits;
 100   }
 101
 102   // Faster comparison in the case we know the namespace is null
 103   bool Equals(nsIAtom* aAtom) const
 104   {
 105     return reinterpret_cast<uintptr_t>(aAtom) == mBits;
 106   }
 107
 108   // And the same but without forcing callers to atomize
 109   bool Equals(const nsAString& aLocalName) const
 110   {
 111     return IsAtom() && Atom()->Equals(aLocalName);
 112   }
 113
 114   bool Equals(nsIAtom* aLocalName, int32_t aNamespaceID) const
 115   {
 116     if (aNamespaceID == kNameSpaceID_None) {
 117       return Equals(aLocalName);
 118     }
 119     return !IsAtom() && NodeInfo()->Equals(aLocalName, aNamespaceID);
 120   }
 121
 122   bool Equals(mozilla::dom::NodeInfo* aNodeInfo) const
 123   {
 124     return Equals(aNodeInfo->NameAtom(), aNodeInfo->NamespaceID());
 125   }
 126
 127   int32_t NamespaceID() const
 128   {
 129     return IsAtom() ? kNameSpaceID_None : NodeInfo()->NamespaceID();
 130   }
 131
 132   int32_t NamespaceEquals(int32_t aNamespaceID) const
 133   {
 134     return aNamespaceID == kNameSpaceID_None ?
 135            IsAtom() :
 136            (!IsAtom() && NodeInfo()->NamespaceEquals(aNamespaceID));
 137   }
 138
 139   nsIAtom* LocalName() const
 140   {
 141     return IsAtom() ? Atom() : NodeInfo()->NameAtom();
 142   }
 143
 144   nsIAtom* GetPrefix() const
 145   {
 146     return IsAtom() ? nullptr : NodeInfo()->GetPrefixAtom();
 147   }
 148
 149   bool QualifiedNameEquals(const nsAString& aName) const
 150   {
 151     return IsAtom() ? Atom()->Equals(aName) :
 152                       NodeInfo()->QualifiedNameEquals(aName);
 153   }
 154
 155   void GetQualifiedName(nsAString& aStr) const
 156   {
 157     if (IsAtom()) {
 158       Atom()->ToString(aStr);
 159     }
 160     else {
 161       aStr = NodeInfo()->QualifiedName();
 162     }
 163   }
 164
 165 #ifdef MOZILLA_INTERNAL_API
 166   void GetPrefix(nsAString& aStr) const
 167   {
 168     if (IsAtom()) {
 169       SetDOMStringToNull(aStr);
 170     }
 171     else {
 172       NodeInfo()->GetPrefix(aStr);
 173     }
 174   }
 175 #endif
 176
 177   uint32_t HashValue() const
 178   {
 179     // mBits and uint32_t might have different size. This should silence
 180     // any warnings or compile-errors. This is what the implementation of
 181     // NS_PTR_TO_INT32 does to take care of the same problem.
 182     return mBits - 0;
 183   }
 184
 185   bool IsSmaller(nsIAtom* aOther) const
 186   {
 187     return mBits < reinterpret_cast<uintptr_t>(aOther);
 188   }
 189
 190 private:
 191
 192   void AddRefInternalName()
 193   {
 194     if (IsAtom()) {
 195       NS_ADDREF(Atom());
 196     } else {
 197       NS_ADDREF(NodeInfo());
 198     }
 199   }
 200
 201   void ReleaseInternalName()
 202   {
 203     if (IsAtom()) {
 204       Atom()->Release();
 205     } else {
 206       NodeInfo()->Release();
 207     }
 208   }
 209
 210   uintptr_t mBits;
 211 };
 212
 213 #endif