OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) | 2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
3 * (C) 1999 Antti Koivisto (koivisto@kde.org) | 3 * (C) 1999 Antti Koivisto (koivisto@kde.org) |
4 * (C) 2001 Dirk Mueller (mueller@kde.org) | 4 * (C) 2001 Dirk Mueller (mueller@kde.org) |
5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. | 5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. |
6 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.t
orchmobile.com/) | 6 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.t
orchmobile.com/) |
7 * Copyright (C) 2014 Samsung Electronics. All rights reserved. | 7 * Copyright (C) 2014 Samsung Electronics. All rights reserved. |
8 * | 8 * |
9 * This library is free software; you can redistribute it and/or | 9 * This library is free software; you can redistribute it and/or |
10 * modify it under the terms of the GNU Library General Public | 10 * modify it under the terms of the GNU Library General Public |
(...skipping 17 matching lines...) Expand all Loading... |
28 | 28 |
29 #include "core/dom/ContainerNode.h" | 29 #include "core/dom/ContainerNode.h" |
30 #include "core/dom/Node.h" | 30 #include "core/dom/Node.h" |
31 | 31 |
32 namespace blink { | 32 namespace blink { |
33 | 33 |
34 template <class Iterator> class TraversalRange; | 34 template <class Iterator> class TraversalRange; |
35 template <class TraversalNext> class TraversalChildrenIterator; | 35 template <class TraversalNext> class TraversalChildrenIterator; |
36 template <class TraversalNext> class TraversalDescendantIterator; | 36 template <class TraversalNext> class TraversalDescendantIterator; |
37 template <class TraversalNext> class TraversalInclusiveDescendantIterator; | 37 template <class TraversalNext> class TraversalInclusiveDescendantIterator; |
38 template <class TraversalNext> class TraversalInclusiveNextIterator; | |
39 template <class TraversalNext> class TraversalNextIterator; | 38 template <class TraversalNext> class TraversalNextIterator; |
40 | 39 |
41 class NodeTraversal { | 40 class NodeTraversal { |
42 public: | 41 public: |
43 using TraversalNodeType = Node; | 42 using TraversalNodeType = Node; |
44 // Does a pre-order traversal of the tree to find the next node after this o
ne. | 43 // Does a pre-order traversal of the tree to find the next node after this o
ne. |
45 // This uses the same order that tags appear in the source file. If the stay
Within | 44 // This uses the same order that tags appear in the source file. If the stay
Within |
46 // argument is non-null, the traversal will stop once the specified node is
reached. | 45 // argument is non-null, the traversal will stop once the specified node is
reached. |
47 // This can be used to restrict traversal to a particular sub-tree. | 46 // This can be used to restrict traversal to a particular sub-tree. |
48 static Node* next(const Node& current) { return traverseNextTemplate(current
); } | 47 static Node* next(const Node& current) { return traverseNextTemplate(current
); } |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
82 | 81 |
83 // Children traversal. | 82 // Children traversal. |
84 static Node* childAt(const Node& parent, unsigned index) { return childAtTem
plate(parent, index); } | 83 static Node* childAt(const Node& parent, unsigned index) { return childAtTem
plate(parent, index); } |
85 static Node* childAt(const ContainerNode& parent, unsigned index) { return c
hildAtTemplate(parent, index); } | 84 static Node* childAt(const ContainerNode& parent, unsigned index) { return c
hildAtTemplate(parent, index); } |
86 | 85 |
87 static Node* nextSibling(const Node& node) { return node.nextSibling(); } | 86 static Node* nextSibling(const Node& node) { return node.nextSibling(); } |
88 | 87 |
89 static TraversalRange<TraversalChildrenIterator<NodeTraversal>> childrenOf(c
onst Node&); | 88 static TraversalRange<TraversalChildrenIterator<NodeTraversal>> childrenOf(c
onst Node&); |
90 static TraversalRange<TraversalDescendantIterator<NodeTraversal>> descendant
sOf(const Node&); | 89 static TraversalRange<TraversalDescendantIterator<NodeTraversal>> descendant
sOf(const Node&); |
91 static TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>> i
nclusiveDescendantsOf(const Node&); | 90 static TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>> i
nclusiveDescendantsOf(const Node&); |
92 static TraversalRange<TraversalInclusiveNextIterator<NodeTraversal>> from(co
nst Node*); | 91 static TraversalRange<TraversalNextIterator<NodeTraversal>> startsAt(const N
ode*); |
93 static TraversalRange<TraversalNextIterator<NodeTraversal>> fromNext(const N
ode&); | 92 static TraversalRange<TraversalNextIterator<NodeTraversal>> startsAfter(cons
t Node&); |
94 | 93 |
95 private: | 94 private: |
96 template <class NodeType> | 95 template <class NodeType> |
97 static Node* traverseNextTemplate(NodeType&); | 96 static Node* traverseNextTemplate(NodeType&); |
98 template <class NodeType> | 97 template <class NodeType> |
99 static Node* traverseNextTemplate(NodeType&, const Node* stayWithin); | 98 static Node* traverseNextTemplate(NodeType&, const Node* stayWithin); |
100 template <class NodeType> | 99 template <class NodeType> |
101 static Node* childAtTemplate(NodeType&, unsigned); | 100 static Node* childAtTemplate(NodeType&, unsigned); |
102 }; | 101 }; |
103 | 102 |
(...skipping 27 matching lines...) Expand all Loading... |
131 explicit TraversalChildrenIterator(const StartNodeType* start) : TraversalIt
eratorBase<TraversalNext>(TraversalNext::firstWithin(*start)) { }; | 130 explicit TraversalChildrenIterator(const StartNodeType* start) : TraversalIt
eratorBase<TraversalNext>(TraversalNext::firstWithin(*start)) { }; |
132 void operator++() { m_current = TraversalNext::nextSibling(*m_current); }; | 131 void operator++() { m_current = TraversalNext::nextSibling(*m_current); }; |
133 static TraversalChildrenIterator end() { return TraversalChildrenIterator();
}; | 132 static TraversalChildrenIterator end() { return TraversalChildrenIterator();
}; |
134 private: | 133 private: |
135 TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr)
{ }; | 134 TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr)
{ }; |
136 }; | 135 }; |
137 | 136 |
138 template <class TraversalNext> | 137 template <class TraversalNext> |
139 class TraversalNextIterator : public TraversalIteratorBase<TraversalNext> { | 138 class TraversalNextIterator : public TraversalIteratorBase<TraversalNext> { |
140 public: | 139 public: |
141 using StartNodeType = Node; | 140 using StartNodeType = typename TraversalNext::TraversalNodeType; |
142 using TraversalIteratorBase<TraversalNext>::m_current; | 141 using TraversalIteratorBase<TraversalNext>::m_current; |
143 explicit TraversalNextIterator(const StartNodeType* start) : TraversalIterat
orBase<TraversalNext>(TraversalNext::next(*start)) { }; | 142 explicit TraversalNextIterator(const StartNodeType* start) : TraversalIterat
orBase<TraversalNext>(const_cast<StartNodeType*>(start)) { }; |
144 void operator++() { m_current = TraversalNext::next(*m_current); } | 143 void operator++() { m_current = TraversalNext::next(*m_current); } |
145 static TraversalNextIterator end() { return TraversalNextIterator(); }; | 144 static TraversalNextIterator end() { return TraversalNextIterator(nullptr);
}; |
146 private: | |
147 TraversalNextIterator() : TraversalIteratorBase<TraversalNext>(nullptr) { }; | |
148 }; | 145 }; |
149 | 146 |
150 template <class TraversalNext> | 147 template <class TraversalNext> |
151 class TraversalInclusiveNextIterator : public TraversalIteratorBase<TraversalNex
t> { | |
152 public: | |
153 using StartNodeType = typename TraversalNext::TraversalNodeType; | |
154 using TraversalIteratorBase<TraversalNext>::m_current; | |
155 explicit TraversalInclusiveNextIterator(const StartNodeType* start) : Traver
salIteratorBase<TraversalNext>(const_cast<StartNodeType*>(start)) { }; | |
156 void operator++() { m_current = TraversalNext::next(*m_current); } | |
157 static TraversalInclusiveNextIterator end() { return TraversalInclusiveNextI
terator(nullptr); }; | |
158 }; | |
159 | |
160 template <class TraversalNext> | |
161 class TraversalDescendantIterator : public TraversalIteratorBase<TraversalNext>
{ | 148 class TraversalDescendantIterator : public TraversalIteratorBase<TraversalNext>
{ |
162 public: | 149 public: |
163 using StartNodeType = Node; | 150 using StartNodeType = Node; |
164 using TraversalIteratorBase<TraversalNext>::m_current; | 151 using TraversalIteratorBase<TraversalNext>::m_current; |
165 explicit TraversalDescendantIterator(const StartNodeType* start) : Traversal
IteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)), m_root(start) {
}; | 152 explicit TraversalDescendantIterator(const StartNodeType* start) : Traversal
IteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)), m_root(start) {
}; |
166 void operator++() { m_current = TraversalNext::next(*m_current, m_root); } | 153 void operator++() { m_current = TraversalNext::next(*m_current, m_root); } |
167 static TraversalDescendantIterator end() { return TraversalDescendantIterato
r(); }; | 154 static TraversalDescendantIterator end() { return TraversalDescendantIterato
r(); }; |
168 private: | 155 private: |
169 TraversalDescendantIterator() : TraversalIteratorBase<TraversalNext>(nullptr
), m_root(nullptr) { }; | 156 TraversalDescendantIterator() : TraversalIteratorBase<TraversalNext>(nullptr
), m_root(nullptr) { }; |
170 const Node* m_root; | 157 const Node* m_root; |
(...skipping 20 matching lines...) Expand all Loading... |
191 inline TraversalRange<TraversalDescendantIterator<NodeTraversal>> NodeTraversal:
:descendantsOf(const Node& root) | 178 inline TraversalRange<TraversalDescendantIterator<NodeTraversal>> NodeTraversal:
:descendantsOf(const Node& root) |
192 { | 179 { |
193 return TraversalRange<TraversalDescendantIterator<NodeTraversal>>(&root); | 180 return TraversalRange<TraversalDescendantIterator<NodeTraversal>>(&root); |
194 } | 181 } |
195 | 182 |
196 inline TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>> NodeT
raversal::inclusiveDescendantsOf(const Node& root) | 183 inline TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>> NodeT
raversal::inclusiveDescendantsOf(const Node& root) |
197 { | 184 { |
198 return TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>>(&
root); | 185 return TraversalRange<TraversalInclusiveDescendantIterator<NodeTraversal>>(&
root); |
199 } | 186 } |
200 | 187 |
201 inline TraversalRange<TraversalInclusiveNextIterator<NodeTraversal>> NodeTravers
al::from(const Node* start) | 188 inline TraversalRange<TraversalNextIterator<NodeTraversal>> NodeTraversal::start
sAt(const Node* start) |
202 { | 189 { |
203 return TraversalRange<TraversalInclusiveNextIterator<NodeTraversal>>(start); | 190 return TraversalRange<TraversalNextIterator<NodeTraversal>>(start); |
204 }; | 191 }; |
205 | 192 |
206 inline TraversalRange<TraversalNextIterator<NodeTraversal>> NodeTraversal::fromN
ext(const Node& start) | 193 inline TraversalRange<TraversalNextIterator<NodeTraversal>> NodeTraversal::start
sAfter(const Node& start) |
207 { | 194 { |
208 return TraversalRange<TraversalNextIterator<NodeTraversal>>(&start); | 195 return startsAt(NodeTraversal::next(start)); |
209 }; | 196 }; |
210 | 197 |
211 template <class NodeType> | 198 template <class NodeType> |
212 inline Node* NodeTraversal::traverseNextTemplate(NodeType& current) | 199 inline Node* NodeTraversal::traverseNextTemplate(NodeType& current) |
213 { | 200 { |
214 if (current.hasChildren()) | 201 if (current.hasChildren()) |
215 return current.firstChild(); | 202 return current.firstChild(); |
216 if (current.nextSibling()) | 203 if (current.nextSibling()) |
217 return current.nextSibling(); | 204 return current.nextSibling(); |
218 return nextAncestorSibling(current); | 205 return nextAncestorSibling(current); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
259 { | 246 { |
260 Node* child = parent.firstChild(); | 247 Node* child = parent.firstChild(); |
261 while (child && index--) | 248 while (child && index--) |
262 child = child->nextSibling(); | 249 child = child->nextSibling(); |
263 return child; | 250 return child; |
264 } | 251 } |
265 | 252 |
266 } // namespace blink | 253 } // namespace blink |
267 | 254 |
268 #endif | 255 #endif |
OLD | NEW |