dom/xslt/xpath/txXPathTreeWalker.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   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 #ifndef txXPathTreeWalker_h__
   7 #define txXPathTreeWalker_h__
   8
   9 #include "txCore.h"
  10 #include "txXPathNode.h"
  11 #include "nsIContentInlines.h"
  12 #include "nsTArray.h"
  13
  14 class nsIAtom;
  15 class nsIDOMDocument;
  16
  17 class txUint32Array : public nsTArray<uint32_t>
  18 {
  19 public:
  20     bool AppendValue(uint32_t aValue)
  21     {
  22         return AppendElement(aValue) != nullptr;
  23     }
  24     bool RemoveValueAt(uint32_t aIndex)
  25     {
  26         if (aIndex < Length()) {
  27             RemoveElementAt(aIndex);
  28         }
  29         return true;
  30     }
  31     uint32_t ValueAt(uint32_t aIndex) const
  32     {
  33         return (aIndex < Length()) ? ElementAt(aIndex) : 0;
  34     }
  35 };
  36
  37 class txXPathTreeWalker
  38 {
  39 public:
  40     txXPathTreeWalker(const txXPathTreeWalker& aOther);
  41     explicit txXPathTreeWalker(const txXPathNode& aNode);
  42
  43     bool getAttr(nsIAtom* aLocalName, int32_t aNSID, nsAString& aValue) const;
  44     int32_t getNamespaceID() const;
  45     uint16_t getNodeType() const;
  46     void appendNodeValue(nsAString& aResult) const;
  47     void getNodeName(nsAString& aName) const;
  48
  49     void moveTo(const txXPathTreeWalker& aWalker);
  50
  51     void moveToRoot();
  52     bool moveToParent();
  53     bool moveToElementById(const nsAString& aID);
  54     bool moveToFirstAttribute();
  55     bool moveToNextAttribute();
  56     bool moveToNamedAttribute(nsIAtom* aLocalName, int32_t aNSID);
  57     bool moveToFirstChild();
  58     bool moveToLastChild();
  59     bool moveToNextSibling();
  60     bool moveToPreviousSibling();
  61
  62     bool isOnNode(const txXPathNode& aNode) const;
  63
  64     const txXPathNode& getCurrentPosition() const;
  65
  66 private:
  67     txXPathNode mPosition;
  68
  69     bool moveToValidAttribute(uint32_t aStartIndex);
  70     bool moveToSibling(int32_t aDir);
  71
  72     uint32_t mCurrentIndex;
  73     txUint32Array mDescendants;
  74 };
  75
  76 class txXPathNodeUtils
  77 {
  78 public:
  79     static bool getAttr(const txXPathNode& aNode, nsIAtom* aLocalName,
  80                           int32_t aNSID, nsAString& aValue);
  81     static already_AddRefed<nsIAtom> getLocalName(const txXPathNode& aNode);
  82     static nsIAtom* getPrefix(const txXPathNode& aNode);
  83     static void getLocalName(const txXPathNode& aNode, nsAString& aLocalName);
  84     static void getNodeName(const txXPathNode& aNode,
  85                             nsAString& aName);
  86     static int32_t getNamespaceID(const txXPathNode& aNode);
  87     static void getNamespaceURI(const txXPathNode& aNode, nsAString& aURI);
  88     static uint16_t getNodeType(const txXPathNode& aNode);
  89     static void appendNodeValue(const txXPathNode& aNode, nsAString& aResult);
  90     static bool isWhitespace(const txXPathNode& aNode);
  91     static txXPathNode* getOwnerDocument(const txXPathNode& aNode);
  92     static int32_t getUniqueIdentifier(const txXPathNode& aNode);
  93     static nsresult getXSLTId(const txXPathNode& aNode,
  94                               const txXPathNode& aBase, nsAString& aResult);
  95     static void release(txXPathNode* aNode);
  96     static void getBaseURI(const txXPathNode& aNode, nsAString& aURI);
  97     static int comparePosition(const txXPathNode& aNode,
  98                                const txXPathNode& aOtherNode);
  99     static bool localNameEquals(const txXPathNode& aNode,
 100                                   nsIAtom* aLocalName);
 101     static bool isRoot(const txXPathNode& aNode);
 102     static bool isElement(const txXPathNode& aNode);
 103     static bool isAttribute(const txXPathNode& aNode);
 104     static bool isProcessingInstruction(const txXPathNode& aNode);
 105     static bool isComment(const txXPathNode& aNode);
 106     static bool isText(const txXPathNode& aNode);
 107     static inline bool isHTMLElementInHTMLDocument(const txXPathNode& aNode)
 108     {
 109       if (!aNode.isContent()) {
 110         return false;
 111       }
 112       nsIContent* content = aNode.Content();
 113       return content->IsHTML() && content->IsInHTMLDocument();
 114     }
 115 };
 116
 117 class txXPathNativeNode
 118 {
 119 public:
 120     static txXPathNode* createXPathNode(nsINode* aNode,
 121                                         bool aKeepRootAlive = false);
 122     static txXPathNode* createXPathNode(nsIDOMNode* aNode,
 123                                         bool aKeepRootAlive = false)
 124     {
 125         nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
 126         return createXPathNode(node, aKeepRootAlive);
 127     }
 128     static txXPathNode* createXPathNode(nsIContent* aContent,
 129                                         bool aKeepRootAlive = false);
 130     static txXPathNode* createXPathNode(nsIDOMDocument* aDocument);
 131     static nsINode* getNode(const txXPathNode& aNode);
 132     static nsresult getNode(const txXPathNode& aNode, nsIDOMNode** aResult)
 133     {
 134         return CallQueryInterface(getNode(aNode), aResult);
 135     }
 136     static nsIContent* getContent(const txXPathNode& aNode);
 137     static nsIDocument* getDocument(const txXPathNode& aNode);
 138     static void addRef(const txXPathNode& aNode)
 139     {
 140         NS_ADDREF(aNode.mNode);
 141     }
 142     static void release(const txXPathNode& aNode)
 143     {
 144         nsINode *node = aNode.mNode;
 145         NS_RELEASE(node);
 146     }
 147 };
 148
 149 inline const txXPathNode&
 150 txXPathTreeWalker::getCurrentPosition() const
 151 {
 152     return mPosition;
 153 }
 154
 155 inline bool
 156 txXPathTreeWalker::getAttr(nsIAtom* aLocalName, int32_t aNSID,
 157                            nsAString& aValue) const
 158 {
 159     return txXPathNodeUtils::getAttr(mPosition, aLocalName, aNSID, aValue);
 160 }
 161
 162 inline int32_t
 163 txXPathTreeWalker::getNamespaceID() const
 164 {
 165     return txXPathNodeUtils::getNamespaceID(mPosition);
 166 }
 167
 168 inline void
 169 txXPathTreeWalker::appendNodeValue(nsAString& aResult) const
 170 {
 171     txXPathNodeUtils::appendNodeValue(mPosition, aResult);
 172 }
 173
 174 inline void
 175 txXPathTreeWalker::getNodeName(nsAString& aName) const
 176 {
 177     txXPathNodeUtils::getNodeName(mPosition, aName);
 178 }
 179
 180 inline void
 181 txXPathTreeWalker::moveTo(const txXPathTreeWalker& aWalker)
 182 {
 183     nsINode *root = nullptr;
 184     if (mPosition.mRefCountRoot) {
 185         root = mPosition.Root();
 186     }
 187     mPosition.mIndex = aWalker.mPosition.mIndex;
 188     mPosition.mRefCountRoot = aWalker.mPosition.mRefCountRoot;
 189     mPosition.mNode = aWalker.mPosition.mNode;
 190     nsINode *newRoot = nullptr;
 191     if (mPosition.mRefCountRoot) {
 192         newRoot = mPosition.Root();
 193     }
 194     if (root != newRoot) {
 195         NS_IF_ADDREF(newRoot);
 196         NS_IF_RELEASE(root);
 197     }
 198
 199     mCurrentIndex = aWalker.mCurrentIndex;
 200     mDescendants.Clear();
 201 }
 202
 203 inline bool
 204 txXPathTreeWalker::isOnNode(const txXPathNode& aNode) const
 205 {
 206     return (mPosition == aNode);
 207 }
 208
 209 /* static */
 210 inline int32_t
 211 txXPathNodeUtils::getUniqueIdentifier(const txXPathNode& aNode)
 212 {
 213     NS_PRECONDITION(!aNode.isAttribute(),
 214                     "Not implemented for attributes.");
 215     return NS_PTR_TO_INT32(aNode.mNode);
 216 }
 217
 218 /* static */
 219 inline void
 220 txXPathNodeUtils::release(txXPathNode* aNode)
 221 {
 222     NS_RELEASE(aNode->mNode);
 223 }
 224
 225 /* static */
 226 inline bool
 227 txXPathNodeUtils::localNameEquals(const txXPathNode& aNode,
 228                                   nsIAtom* aLocalName)
 229 {
 230     if (aNode.isContent() &&
 231         aNode.Content()->IsElement()) {
 232         return aNode.Content()->NodeInfo()->Equals(aLocalName);
 233     }
 234
 235     nsCOMPtr<nsIAtom> localName = txXPathNodeUtils::getLocalName(aNode);
 236
 237     return localName == aLocalName;
 238 }
 239
 240 /* static */
 241 inline bool
 242 txXPathNodeUtils::isRoot(const txXPathNode& aNode)
 243 {
 244     return !aNode.isAttribute() && !aNode.mNode->GetParentNode();
 245 }
 246
 247 /* static */
 248 inline bool
 249 txXPathNodeUtils::isElement(const txXPathNode& aNode)
 250 {
 251     return aNode.isContent() &&
 252            aNode.Content()->IsElement();
 253 }
 254
 255
 256 /* static */
 257 inline bool
 258 txXPathNodeUtils::isAttribute(const txXPathNode& aNode)
 259 {
 260     return aNode.isAttribute();
 261 }
 262
 263 /* static */
 264 inline bool
 265 txXPathNodeUtils::isProcessingInstruction(const txXPathNode& aNode)
 266 {
 267     return aNode.isContent() &&
 268            aNode.Content()->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION);
 269 }
 270
 271 /* static */
 272 inline bool
 273 txXPathNodeUtils::isComment(const txXPathNode& aNode)
 274 {
 275     return aNode.isContent() &&
 276            aNode.Content()->IsNodeOfType(nsINode::eCOMMENT);
 277 }
 278
 279 /* static */
 280 inline bool
 281 txXPathNodeUtils::isText(const txXPathNode& aNode)
 282 {
 283     return aNode.isContent() &&
 284            aNode.Content()->IsNodeOfType(nsINode::eTEXT);
 285 }
 286
 287 #endif /* txXPathTreeWalker_h__ */