Add lineageOfType renderer iterator and start using it.
[WebKit-https.git] / Source / WebCore / rendering / RenderAncestorIterator.h
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef RenderAncestorIterator_h
27 #define RenderAncestorIterator_h
28
29 #include "RenderIterator.h"
30
31 namespace WebCore {
32
33 template <typename T>
34 class RenderAncestorIterator : public RenderIterator<T> {
35 public:
36     RenderAncestorIterator();
37     explicit RenderAncestorIterator(T* current);
38     RenderAncestorIterator& operator++();
39 };
40
41 template <typename T>
42 class RenderAncestorConstIterator : public RenderConstIterator<T> {
43 public:
44     RenderAncestorConstIterator();
45     explicit RenderAncestorConstIterator(const T* current);
46     RenderAncestorConstIterator& operator++();
47 };
48
49 template <typename T>
50 class RenderAncestorIteratorAdapter {
51 public:
52     RenderAncestorIteratorAdapter(T* first);
53     RenderAncestorIterator<T> begin();
54     RenderAncestorIterator<T> end();
55     T* first();
56
57 private:
58     T* m_first;
59 };
60
61 template <typename T>
62 class RenderAncestorConstIteratorAdapter {
63 public:
64     RenderAncestorConstIteratorAdapter(const T* first);
65     RenderAncestorConstIterator<T> begin() const;
66     RenderAncestorConstIterator<T> end() const;
67     const T* first() const;
68
69 private:
70     const T* m_first;
71 };
72
73 template <typename T> RenderAncestorIteratorAdapter<T> ancestorsOfType(RenderObject&);
74 template <typename T> RenderAncestorConstIteratorAdapter<T> ancestorsOfType(const RenderObject&);
75 template <typename T> RenderAncestorIteratorAdapter<T> lineageOfType(RenderObject&);
76 template <typename T> RenderAncestorConstIteratorAdapter<T> lineageOfType(const RenderObject&);
77
78 // RenderAncestorIterator
79
80 template <typename T>
81 inline RenderAncestorIterator<T>::RenderAncestorIterator()
82     : RenderIterator<T>(nullptr)
83 {
84 }
85
86 template <typename T>
87 inline RenderAncestorIterator<T>::RenderAncestorIterator(T* current)
88     : RenderIterator<T>(nullptr, current)
89 {
90 }
91
92 template <typename T>
93 inline RenderAncestorIterator<T>& RenderAncestorIterator<T>::operator++()
94 {
95     return static_cast<RenderAncestorIterator<T>&>(RenderIterator<T>::traverseAncestor());
96 }
97
98 // RenderAncestorConstIterator
99
100 template <typename T>
101 inline RenderAncestorConstIterator<T>::RenderAncestorConstIterator()
102     : RenderConstIterator<T>(nullptr)
103 {
104 }
105
106 template <typename T>
107 inline RenderAncestorConstIterator<T>::RenderAncestorConstIterator(const T* current)
108     : RenderConstIterator<T>(nullptr, current)
109 {
110 }
111
112 template <typename T>
113 inline RenderAncestorConstIterator<T>& RenderAncestorConstIterator<T>::operator++()
114 {
115     return static_cast<RenderAncestorConstIterator<T>&>(RenderConstIterator<T>::traverseAncestor());
116 }
117
118 // RenderAncestorIteratorAdapter
119
120 template <typename T>
121 inline RenderAncestorIteratorAdapter<T>::RenderAncestorIteratorAdapter(T* first)
122     : m_first(first)
123 {
124 }
125
126 template <typename T>
127 inline RenderAncestorIterator<T> RenderAncestorIteratorAdapter<T>::begin()
128 {
129     return RenderAncestorIterator<T>(m_first);
130 }
131
132 template <typename T>
133 inline RenderAncestorIterator<T> RenderAncestorIteratorAdapter<T>::end()
134 {
135     return RenderAncestorIterator<T>();
136 }
137
138 template <typename T>
139 inline T* RenderAncestorIteratorAdapter<T>::first()
140 {
141     return m_first;
142 }
143
144 // RenderAncestorConstIteratorAdapter
145
146 template <typename T>
147 inline RenderAncestorConstIteratorAdapter<T>::RenderAncestorConstIteratorAdapter(const T* first)
148     : m_first(first)
149 {
150 }
151
152 template <typename T>
153 inline RenderAncestorConstIterator<T> RenderAncestorConstIteratorAdapter<T>::begin() const
154 {
155     return RenderAncestorConstIterator<T>(m_first);
156 }
157
158 template <typename T>
159 inline RenderAncestorConstIterator<T> RenderAncestorConstIteratorAdapter<T>::end() const
160 {
161     return RenderAncestorConstIterator<T>();
162 }
163
164 template <typename T>
165 inline const T* RenderAncestorConstIteratorAdapter<T>::first() const
166 {
167     return m_first;
168 }
169
170 // Standalone functions
171
172 template <typename T>
173 inline RenderAncestorIteratorAdapter<T> ancestorsOfType(RenderObject& descendant)
174 {
175     T* first = RenderTraversal::findAncestorOfType<T>(descendant);
176     return RenderAncestorIteratorAdapter<T>(first);
177 }
178
179 template <typename T>
180 inline RenderAncestorConstIteratorAdapter<T> ancestorsOfType(const RenderObject& descendant)
181 {
182     const T* first = RenderTraversal::findAncestorOfType<const T>(descendant);
183     return RenderAncestorConstIteratorAdapter<T>(first);
184 }
185
186 template <typename T>
187 inline RenderAncestorIteratorAdapter<T> lineageOfType(RenderObject& first)
188 {
189     if (isRendererOfType<const T>(first))
190         return RenderAncestorIteratorAdapter<T>(static_cast<T*>(&first));
191     return ancestorsOfType<T>(first);
192 }
193
194 template <typename T>
195 inline RenderAncestorConstIteratorAdapter<T> lineageOfType(const RenderObject& first)
196 {
197     if (isRendererOfType<const T>(first))
198         return RenderAncestorConstIteratorAdapter<T>(static_cast<const T*>(&first));
199     return ancestorsOfType<T>(first);
200 }
201
202 }
203
204 #endif