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