Line data    Source code

       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 txXPathNode_h__
       7             : #define txXPathNode_h__
       8             : 
       9             : #include "nsAutoPtr.h"
      10             : #include "nsIContent.h"
      11             : #include "nsIDocument.h"
      12             : #include "nsIDOMNode.h"
      13             : #include "nsNameSpaceManager.h"
      14             : #include "nsContentUtils.h" // For NameSpaceManager().
      15             : 
      16             : typedef nsIDOMNode txXPathNodeType;
      17             : 
      18             : class txXPathNode
      19             : {
      20             : public:
      21             :     bool operator==(const txXPathNode& aNode) const;
      22           0 :     bool operator!=(const txXPathNode& aNode) const
      23             :     {
      24           0 :         return !(*this == aNode);
      25             :     }
      26             :     ~txXPathNode();
      27             : 
      28             : private:
      29             :     friend class txNodeSet;
      30             :     friend class txXPathNativeNode;
      31             :     friend class txXPathNodeUtils;
      32             :     friend class txXPathTreeWalker;
      33             : 
      34             :     txXPathNode(const txXPathNode& aNode);
      35             : 
      36           0 :     explicit txXPathNode(nsIDocument* aDocument) : mNode(aDocument),
      37             :                                                    mRefCountRoot(0),
      38           0 :                                                    mIndex(eDocument)
      39             :     {
      40           0 :         MOZ_COUNT_CTOR(txXPathNode);
      41           0 :     }
      42           0 :     txXPathNode(nsINode *aNode, uint32_t aIndex, nsINode *aRoot)
      43           0 :         : mNode(aNode),
      44           0 :           mRefCountRoot(aRoot ? 1 : 0),
      45           0 :           mIndex(aIndex)
      46             :     {
      47           0 :         MOZ_COUNT_CTOR(txXPathNode);
      48           0 :         if (aRoot) {
      49           0 :             NS_ADDREF(aRoot);
      50             :         }
      51           0 :     }
      52             : 
      53           0 :     static nsINode *RootOf(nsINode *aNode)
      54             :     {
      55           0 :         nsINode *ancestor, *root = aNode;
      56           0 :         while ((ancestor = root->GetParentNode())) {
      57           0 :             root = ancestor;
      58             :         }
      59           0 :         return root;
      60             :     }
      61           0 :     nsINode *Root() const
      62             :     {
      63           0 :         return RootOf(mNode);
      64             :     }
      65             :     nsINode *GetRootToAddRef() const
      66             :     {
      67             :         return mRefCountRoot ? Root() : nullptr;
      68             :     }
      69             : 
      70           0 :     bool isDocument() const
      71             :     {
      72           0 :         return mIndex == eDocument;
      73             :     }
      74           0 :     bool isContent() const
      75             :     {
      76           0 :         return mIndex == eContent;
      77             :     }
      78           0 :     bool isAttribute() const
      79             :     {
      80           0 :         return mIndex != eDocument && mIndex != eContent;
      81             :     }
      82             : 
      83           0 :     nsIContent* Content() const
      84             :     {
      85           0 :         NS_ASSERTION(isContent() || isAttribute(), "wrong type");
      86           0 :         return static_cast<nsIContent*>(mNode);
      87             :     }
      88           0 :     nsIDocument* Document() const
      89             :     {
      90           0 :         NS_ASSERTION(isDocument(), "wrong type");
      91           0 :         return static_cast<nsIDocument*>(mNode);
      92             :     }
      93             : 
      94             :     enum PositionType
      95             :     {
      96             :         eDocument = (1 << 30),
      97             :         eContent = eDocument - 1
      98             :     };
      99             : 
     100             :     nsINode* mNode;
     101             :     uint32_t mRefCountRoot : 1;
     102             :     uint32_t mIndex : 31;
     103             : };
     104             : 
     105             : class txNamespaceManager
     106             : {
     107             : public:
     108             :     static int32_t getNamespaceID(const nsAString& aNamespaceURI);
     109             :     static nsresult getNamespaceURI(const int32_t aID, nsAString& aResult);
     110             : };
     111             : 
     112             : /* static */
     113             : inline int32_t
     114          48 : txNamespaceManager::getNamespaceID(const nsAString& aNamespaceURI)
     115             : {
     116          48 :     int32_t namespaceID = kNameSpaceID_Unknown;
     117             :     nsContentUtils::NameSpaceManager()->
     118          48 :         RegisterNameSpace(aNamespaceURI, namespaceID);
     119          48 :     return namespaceID;
     120             : }
     121             : 
     122             : /* static */
     123             : inline nsresult
     124           0 : txNamespaceManager::getNamespaceURI(const int32_t aID, nsAString& aResult)
     125             : {
     126             :     return nsContentUtils::NameSpaceManager()->
     127           0 :         GetNameSpaceURI(aID, aResult);
     128             : }
     129             : 
     130             : inline bool
     131           0 : txXPathNode::operator==(const txXPathNode& aNode) const
     132             : {
     133           0 :     return mIndex == aNode.mIndex && mNode == aNode.mNode;
     134             : }
     135             : 
     136             : #endif /* txXPathNode_h__ */