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 13 matching lines...) Expand all Loading... | |
24 */ | 24 */ |
25 | 25 |
26 #ifndef ElementTraversal_h | 26 #ifndef ElementTraversal_h |
27 #define ElementTraversal_h | 27 #define ElementTraversal_h |
28 | 28 |
29 #include "core/dom/Element.h" | 29 #include "core/dom/Element.h" |
30 #include "core/dom/NodeTraversal.h" | 30 #include "core/dom/NodeTraversal.h" |
31 | 31 |
32 namespace WebCore { | 32 namespace WebCore { |
33 | 33 |
34 class ElementTraversal { | 34 template <class ElementType> |
35 class Traversal { | |
35 public: | 36 public: |
36 // First / Last element child of the node. | 37 // First / Last element child of the node. |
37 static Element* firstWithin(const ContainerNode& current) { return firstElem entWithinTemplate(current); } | 38 static ElementType* firstWithin(const ContainerNode& current) { return first ElementWithinTemplate(current); } |
38 static Element* firstWithin(const Node& current) { return firstElementWithin Template(current); } | 39 static ElementType* firstWithin(const Node& current) { return firstElementWi thinTemplate(current); } |
39 static Element* lastWithin(const ContainerNode& current) { return lastWithin Template(current); } | 40 static ElementType* lastWithin(const ContainerNode& current) { return lastWi thinTemplate(current); } |
40 static Element* lastWithin(const Node& current) { return lastWithinTemplate( current); } | 41 static ElementType* lastWithin(const Node& current) { return lastWithinTempl ate(current); } |
41 | 42 |
42 // Pre-order traversal skipping non-element nodes. | 43 // Pre-order traversal skipping non-element nodes. |
43 static Element* next(const ContainerNode& current) { return traverseNextElem entTemplate(current); } | 44 static ElementType* next(const ContainerNode& current) { return traverseNext ElementTemplate(current); } |
44 static Element* next(const Node& current) { return traverseNextElementTempla te(current); } | 45 static ElementType* next(const Node& current) { return traverseNextElementTe mplate(current); } |
45 static Element* next(const ContainerNode& current, const Node* stayWithin) { return traverseNextElementTemplate(current, stayWithin); } | 46 static ElementType* next(const ContainerNode& current, const Node* stayWithi n) { return traverseNextElementTemplate(current, stayWithin); } |
46 static Element* next(const Node& current, const Node* stayWithin) { return t raverseNextElementTemplate(current, stayWithin); } | 47 static ElementType* next(const Node& current, const Node* stayWithin) { retu rn traverseNextElementTemplate(current, stayWithin); } |
47 | 48 |
48 // Like next, but skips children. | 49 // Like next, but skips children. |
49 static Element* nextSkippingChildren(const ContainerNode& current) { return traverseNextElementSkippingChildrenTemplate(current); } | 50 static ElementType* nextSkippingChildren(const ContainerNode& current) { ret urn traverseNextElementSkippingChildrenTemplate(current); } |
50 static Element* nextSkippingChildren(const Node& current) { return traverseN extElementSkippingChildrenTemplate(current); } | 51 static ElementType* nextSkippingChildren(const Node& current) { return trave rseNextElementSkippingChildrenTemplate(current); } |
51 static Element* nextSkippingChildren(const ContainerNode& current, const Nod e* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, sta yWithin); } | 52 static ElementType* nextSkippingChildren(const ContainerNode& current, const Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); } |
52 static Element* nextSkippingChildren(const Node& current, const Node* stayWi thin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); } | 53 static ElementType* nextSkippingChildren(const Node& current, const Node* st ayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWith in); } |
53 | 54 |
54 // Pre-order traversal including the pseudo-elements. | 55 // Pre-order traversal including the pseudo-elements. |
55 static Element* previousIncludingPseudo(const Node&, const Node* stayWithin = 0); | 56 static ElementType* previousIncludingPseudo(const Node&, const Node* stayWit hin = 0); |
56 static Element* nextIncludingPseudo(const Node&, const Node* stayWithin = 0) ; | 57 static ElementType* nextIncludingPseudo(const Node&, const Node* stayWithin = 0); |
57 static Element* nextIncludingPseudoSkippingChildren(const Node&, const Node* stayWithin = 0); | 58 static ElementType* nextIncludingPseudoSkippingChildren(const Node&, const N ode* stayWithin = 0); |
58 | 59 |
59 // Utility function to traverse only the element and pseudo-element siblings of a node. | 60 // Utility function to traverse only the element and pseudo-element siblings of a node. |
60 static Element* pseudoAwarePreviousSibling(const Node&); | 61 static ElementType* pseudoAwarePreviousSibling(const Node&); |
61 | 62 |
62 // Previous / Next sibling. | 63 // Previous / Next sibling. |
63 static Element* previousSibling(const Node&); | 64 static ElementType* previousSibling(const Node&); |
64 static Element* nextSibling(const Node&); | 65 static ElementType* nextSibling(const Node&); |
65 | 66 |
66 private: | 67 private: |
67 template <class NodeType> | 68 template <class NodeType> |
68 static Element* firstElementWithinTemplate(NodeType&); | 69 static ElementType* firstElementWithinTemplate(NodeType&); |
69 template <class NodeType> | 70 template <class NodeType> |
70 static Element* lastWithinTemplate(NodeType&); | 71 static ElementType* lastWithinTemplate(NodeType&); |
71 template <class NodeType> | 72 template <class NodeType> |
72 static Element* traverseNextElementTemplate(NodeType&); | 73 static ElementType* traverseNextElementTemplate(NodeType&); |
73 template <class NodeType> | 74 template <class NodeType> |
74 static Element* traverseNextElementTemplate(NodeType&, const Node* stayWithi n); | 75 static ElementType* traverseNextElementTemplate(NodeType&, const Node* stayW ithin); |
75 template <class NodeType> | 76 template <class NodeType> |
76 static Element* traverseNextElementSkippingChildrenTemplate(NodeType&); | 77 static ElementType* traverseNextElementSkippingChildrenTemplate(NodeType&); |
77 template <class NodeType> | 78 template <class NodeType> |
78 static Element* traverseNextElementSkippingChildrenTemplate(NodeType&, const Node* stayWithin); | 79 static ElementType* traverseNextElementSkippingChildrenTemplate(NodeType&, c onst Node* stayWithin); |
79 }; | 80 }; |
80 | 81 |
82 typedef Traversal<Element> ElementTraversal; | |
83 | |
84 template <class ElementType> | |
81 template <class NodeType> | 85 template <class NodeType> |
82 inline Element* ElementTraversal::firstElementWithinTemplate(NodeType& current) | 86 inline ElementType* Traversal<ElementType>::firstElementWithinTemplate(NodeType& current) |
83 { | 87 { |
84 // Except for the root containers, only elements can have element children. | 88 // Except for the root containers, only elements can have element children. |
85 Node* node = current.firstChild(); | 89 Node* node = current.firstChild(); |
86 while (node && !node->isElementNode()) | 90 while (node && !isElementOfType<ElementType>(*node)) |
87 node = node->nextSibling(); | 91 node = node->nextSibling(); |
88 return toElement(node); | 92 return toElement<ElementType>(node); |
89 } | 93 } |
90 | 94 |
95 template <class ElementType> | |
91 template <class NodeType> | 96 template <class NodeType> |
92 inline Element* ElementTraversal::lastWithinTemplate(NodeType& current) | 97 inline ElementType* Traversal<ElementType>::lastWithinTemplate(NodeType& current ) |
93 { | 98 { |
94 Node* node = current.lastChild(); | 99 Node* node = current.lastChild(); |
95 while (node && !node->isElementNode()) | 100 while (node && !isElementOfType<ElementType>(*node)) |
96 node = node->previousSibling(); | 101 node = node->previousSibling(); |
97 return toElement(node); | 102 return toElement<ElementType>(node); |
98 } | 103 } |
99 | 104 |
105 template <class ElementType> | |
esprehn
2014/02/26 20:17:49
Why stack two template<> decls instead of doing te
Inactive
2014/02/26 20:24:25
This does not build (just double-checked). one tem
Inactive
2014/02/26 20:29:13
FYI, since I googled it as well:
http://stackoverf
| |
100 template <class NodeType> | 106 template <class NodeType> |
101 inline Element* ElementTraversal::traverseNextElementTemplate(NodeType& current) | 107 inline ElementType* Traversal<ElementType>::traverseNextElementTemplate(NodeType & current) |
102 { | 108 { |
103 Node* node = NodeTraversal::next(current); | 109 Node* node = NodeTraversal::next(current); |
104 while (node && !node->isElementNode()) | 110 while (node && !isElementOfType<ElementType>(*node)) |
105 node = NodeTraversal::nextSkippingChildren(*node); | 111 node = NodeTraversal::nextSkippingChildren(*node); |
106 return toElement(node); | 112 return toElement<ElementType>(node); |
107 } | 113 } |
108 | 114 |
115 template <class ElementType> | |
109 template <class NodeType> | 116 template <class NodeType> |
110 inline Element* ElementTraversal::traverseNextElementTemplate(NodeType& current, const Node* stayWithin) | 117 inline ElementType* Traversal<ElementType>::traverseNextElementTemplate(NodeType & current, const Node* stayWithin) |
111 { | 118 { |
112 Node* node = NodeTraversal::next(current, stayWithin); | 119 Node* node = NodeTraversal::next(current, stayWithin); |
113 while (node && !node->isElementNode()) | 120 while (node && !isElementOfType<ElementType>(*node)) |
114 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); | 121 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); |
115 return toElement(node); | 122 return toElement<ElementType>(node); |
116 } | 123 } |
117 | 124 |
125 template <class ElementType> | |
118 template <class NodeType> | 126 template <class NodeType> |
119 inline Element* ElementTraversal::traverseNextElementSkippingChildrenTemplate(No deType& current) | 127 inline ElementType* Traversal<ElementType>::traverseNextElementSkippingChildrenT emplate(NodeType& current) |
120 { | 128 { |
121 Node* node = NodeTraversal::nextSkippingChildren(current); | 129 Node* node = NodeTraversal::nextSkippingChildren(current); |
122 while (node && !node->isElementNode()) | 130 while (node && !isElementOfType<ElementType>(*node)) |
123 node = NodeTraversal::nextSkippingChildren(*node); | 131 node = NodeTraversal::nextSkippingChildren(*node); |
124 return toElement(node); | 132 return toElement<ElementType>(node); |
125 } | 133 } |
126 | 134 |
135 template <class ElementType> | |
127 template <class NodeType> | 136 template <class NodeType> |
128 inline Element* ElementTraversal::traverseNextElementSkippingChildrenTemplate(No deType& current, const Node* stayWithin) | 137 inline ElementType* Traversal<ElementType>::traverseNextElementSkippingChildrenT emplate(NodeType& current, const Node* stayWithin) |
129 { | 138 { |
130 Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin); | 139 Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin); |
131 while (node && !node->isElementNode()) | 140 while (node && !isElementOfType<ElementType>(*node)) |
132 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); | 141 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); |
133 return toElement(node); | 142 return toElement<ElementType>(node); |
134 } | 143 } |
135 | 144 |
136 inline Element* ElementTraversal::previousIncludingPseudo(const Node& current, c onst Node* stayWithin) | 145 template <class ElementType> |
146 inline ElementType* Traversal<ElementType>::previousIncludingPseudo(const Node& current, const Node* stayWithin) | |
137 { | 147 { |
138 Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin); | 148 Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin); |
139 while (node && !node->isElementNode()) | 149 while (node && !isElementOfType<ElementType>(*node)) |
140 node = NodeTraversal::previousIncludingPseudo(*node, stayWithin); | 150 node = NodeTraversal::previousIncludingPseudo(*node, stayWithin); |
141 return toElement(node); | 151 return toElement<ElementType>(node); |
142 } | 152 } |
143 | 153 |
144 inline Element* ElementTraversal::nextIncludingPseudo(const Node& current, const Node* stayWithin) | 154 template <class ElementType> |
155 inline ElementType* Traversal<ElementType>::nextIncludingPseudo(const Node& curr ent, const Node* stayWithin) | |
145 { | 156 { |
146 Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin); | 157 Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin); |
147 while (node && !node->isElementNode()) | 158 while (node && !isElementOfType<ElementType>(*node)) |
148 node = NodeTraversal::nextIncludingPseudo(*node, stayWithin); | 159 node = NodeTraversal::nextIncludingPseudo(*node, stayWithin); |
149 return toElement(node); | 160 return toElement<ElementType>(node); |
150 } | 161 } |
151 | 162 |
152 inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node & current, const Node* stayWithin) | 163 template <class ElementType> |
164 inline ElementType* Traversal<ElementType>::nextIncludingPseudoSkippingChildren( const Node& current, const Node* stayWithin) | |
153 { | 165 { |
154 Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, sta yWithin); | 166 Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, sta yWithin); |
155 while (node && !node->isElementNode()) | 167 while (node && !isElementOfType<ElementType>(*node)) |
156 node = NodeTraversal::nextIncludingPseudoSkippingChildren(*node, stayWit hin); | 168 node = NodeTraversal::nextIncludingPseudoSkippingChildren(*node, stayWit hin); |
157 return toElement(node); | 169 return toElement<ElementType>(node); |
158 } | 170 } |
159 | 171 |
160 inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node& current ) | 172 template <class ElementType> |
173 inline ElementType* Traversal<ElementType>::pseudoAwarePreviousSibling(const Nod e& current) | |
161 { | 174 { |
162 Node* node = current.pseudoAwarePreviousSibling(); | 175 Node* node = current.pseudoAwarePreviousSibling(); |
163 while (node && !node->isElementNode()) | 176 while (node && !isElementOfType<ElementType>(*node)) |
164 node = node->pseudoAwarePreviousSibling(); | 177 node = node->pseudoAwarePreviousSibling(); |
165 return toElement(node); | 178 return toElement<ElementType>(node); |
166 } | 179 } |
167 | 180 |
168 inline Element* ElementTraversal::previousSibling(const Node& current) | 181 template <class ElementType> |
182 inline ElementType* Traversal<ElementType>::previousSibling(const Node& current) | |
169 { | 183 { |
170 Node* node = current.previousSibling(); | 184 Node* node = current.previousSibling(); |
171 while (node && !node->isElementNode()) | 185 while (node && !isElementOfType<ElementType>(*node)) |
172 node = node->previousSibling(); | 186 node = node->previousSibling(); |
173 return toElement(node); | 187 return toElement<ElementType>(node); |
174 } | 188 } |
175 | 189 |
176 inline Element* ElementTraversal::nextSibling(const Node& current) | 190 template <class ElementType> |
191 inline ElementType* Traversal<ElementType>::nextSibling(const Node& current) | |
177 { | 192 { |
178 Node* node = current.nextSibling(); | 193 Node* node = current.nextSibling(); |
179 while (node && !node->isElementNode()) | 194 while (node && !isElementOfType<ElementType>(*node)) |
180 node = node->nextSibling(); | 195 node = node->nextSibling(); |
181 return toElement(node); | 196 return toElement<ElementType>(node); |
182 } | 197 } |
183 | 198 |
184 } // namespace WebCore | 199 } // namespace WebCore |
185 | 200 |
186 #endif | 201 #endif |
OLD | NEW |