1 | /* |
2 | * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved. |
3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 | * |
5 | * This code is free software; you can redistribute it and/or modify it |
6 | * under the terms of the GNU General Public License version 2 only, as |
7 | * published by the Free Software Foundation. Sun designates this |
8 | * particular file as subject to the "Classpath" exception as provided |
9 | * by Sun in the LICENSE file that accompanied this code. |
10 | * |
11 | * This code is distributed in the hope that it will be useful, but WITHOUT |
12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
14 | * version 2 for more details (a copy is included in the LICENSE file that |
15 | * accompanied this code). |
16 | * |
17 | * You should have received a copy of the GNU General Public License version |
18 | * 2 along with this work; if not, write to the Free Software Foundation, |
19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
20 | * |
21 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
22 | * CA 95054 USA or visit www.sun.com if you need additional information or |
23 | * have any questions. |
24 | */ |
25 | |
26 | package javax.lang.model.util; |
27 | |
28 | |
29 | import javax.lang.model.type.*; |
30 | import javax.annotation.processing.SupportedSourceVersion; |
31 | import static javax.lang.model.element.ElementKind.*; |
32 | import static javax.lang.model.SourceVersion.*; |
33 | import javax.lang.model.SourceVersion; |
34 | |
35 | /** |
36 | * A visitor of types based on their {@linkplain TypeKind kind} with |
37 | * default behavior appropriate for the {@link SourceVersion#RELEASE_6 |
38 | * RELEASE_6} source version. For {@linkplain |
39 | * TypeMirror types} <tt><i>XYZ</i></tt> that may have more than one |
40 | * kind, the <tt>visit<i>XYZ</i></tt> methods in this class delegate |
41 | * to the <tt>visit<i>XYZKind</i></tt> method corresponding to the |
42 | * first argument's kind. The <tt>visit<i>XYZKind</i></tt> methods |
43 | * call {@link #defaultAction defaultAction}, passing their arguments |
44 | * to {@code defaultAction}'s corresponding parameters. |
45 | * |
46 | * <p> Methods in this class may be overridden subject to their |
47 | * general contract. Note that annotating methods in concrete |
48 | * subclasses with {@link java.lang.Override @Override} will help |
49 | * ensure that methods are overridden as intended. |
50 | * |
51 | * <p> <b>WARNING:</b> The {@code TypeVisitor} interface implemented |
52 | * by this class may have methods added to it in the future to |
53 | * accommodate new, currently unknown, language structures added to |
54 | * future versions of the Java™ programming language. |
55 | * Therefore, methods whose names begin with {@code "visit"} may be |
56 | * added to this class in the future; to avoid incompatibilities, |
57 | * classes which extend this class should not declare any instance |
58 | * methods with names beginning with {@code "visit"}. |
59 | * |
60 | * <p>When such a new visit method is added, the default |
61 | * implementation in this class will be to call the {@link |
62 | * #visitUnknown visitUnknown} method. A new type kind visitor class |
63 | * will also be introduced to correspond to the new language level; |
64 | * this visitor will have different default behavior for the visit |
65 | * method in question. When the new visitor is introduced, all or |
66 | * portions of this visitor may be deprecated. |
67 | * |
68 | * @param <R> the return type of this visitor's methods. Use {@link |
69 | * Void} for visitors that do not need to return results. |
70 | * @param <P> the type of the additional parameter to this visitor's |
71 | * methods. Use {@code Void} for visitors that do not need an |
72 | * additional parameter. |
73 | * |
74 | * @author Joseph D. Darcy |
75 | * @author Scott Seligman |
76 | * @author Peter von der Ahé |
77 | * @since 1.6 |
78 | */ |
79 | @SupportedSourceVersion(RELEASE_6) |
80 | public class TypeKindVisitor6<R, P> extends SimpleTypeVisitor6<R, P> { |
81 | /** |
82 | * Constructor for concrete subclasses to call; uses {@code null} |
83 | * for the default value. |
84 | */ |
85 | protected TypeKindVisitor6() { |
86 | super(null); |
87 | } |
88 | |
89 | |
90 | /** |
91 | * Constructor for concrete subclasses to call; uses the argument |
92 | * for the default value. |
93 | * |
94 | * @param defaultValue the value to assign to {@link #DEFAULT_VALUE} |
95 | */ |
96 | protected TypeKindVisitor6(R defaultValue) { |
97 | super(defaultValue); |
98 | } |
99 | |
100 | /** |
101 | * Visits a primitive type, dispatching to the visit method for |
102 | * the specific {@linkplain TypeKind kind} of primitive type: |
103 | * {@code BOOLEAN}, {@code BYTE}, etc. |
104 | * |
105 | * @param t {@inheritDoc} |
106 | * @param p {@inheritDoc} |
107 | * @return the result of the kind-specific visit method |
108 | */ |
109 | @Override |
110 | public R visitPrimitive(PrimitiveType t, P p) { |
111 | TypeKind k = t.getKind(); |
112 | switch (k) { |
113 | case BOOLEAN: |
114 | return visitPrimitiveAsBoolean(t, p); |
115 | |
116 | case BYTE: |
117 | return visitPrimitiveAsByte(t, p); |
118 | |
119 | case SHORT: |
120 | return visitPrimitiveAsShort(t, p); |
121 | |
122 | case INT: |
123 | return visitPrimitiveAsInt(t, p); |
124 | |
125 | case LONG: |
126 | return visitPrimitiveAsLong(t, p); |
127 | |
128 | case CHAR: |
129 | return visitPrimitiveAsChar(t, p); |
130 | |
131 | case FLOAT: |
132 | return visitPrimitiveAsFloat(t, p); |
133 | |
134 | case DOUBLE: |
135 | return visitPrimitiveAsDouble(t, p); |
136 | |
137 | default: |
138 | throw new AssertionError("Bad kind " + k + " for PrimitiveType" + t); |
139 | } |
140 | } |
141 | |
142 | /** |
143 | * Visits a {@code BOOLEAN} primitive type by calling |
144 | * {@code defaultAction}. |
145 | * |
146 | * @param t the type to visit |
147 | * @param p a visitor-specified parameter |
148 | * @return the result of {@code defaultAction} |
149 | */ |
150 | public R visitPrimitiveAsBoolean(PrimitiveType t, P p) { |
151 | return defaultAction(t, p); |
152 | } |
153 | |
154 | /** |
155 | * Visits a {@code BYTE} primitive type by calling |
156 | * {@code defaultAction}. |
157 | * |
158 | * @param t the type to visit |
159 | * @param p a visitor-specified parameter |
160 | * @return the result of {@code defaultAction} |
161 | */ |
162 | public R visitPrimitiveAsByte(PrimitiveType t, P p) { |
163 | return defaultAction(t, p); |
164 | } |
165 | |
166 | /** |
167 | * Visits a {@code SHORT} primitive type by calling |
168 | * {@code defaultAction}. |
169 | * |
170 | * @param t the type to visit |
171 | * @param p a visitor-specified parameter |
172 | * @return the result of {@code defaultAction} |
173 | */ |
174 | public R visitPrimitiveAsShort(PrimitiveType t, P p) { |
175 | return defaultAction(t, p); |
176 | } |
177 | |
178 | /** |
179 | * Visits an {@code INT} primitive type by calling |
180 | * {@code defaultAction}. |
181 | * |
182 | * @param t the type to visit |
183 | * @param p a visitor-specified parameter |
184 | * @return the result of {@code defaultAction} |
185 | */ |
186 | public R visitPrimitiveAsInt(PrimitiveType t, P p) { |
187 | return defaultAction(t, p); |
188 | } |
189 | |
190 | /** |
191 | * Visits a {@code LONG} primitive type by calling |
192 | * {@code defaultAction}. |
193 | * |
194 | * @param t the type to visit |
195 | * @param p a visitor-specified parameter |
196 | * @return the result of {@code defaultAction} |
197 | */ |
198 | public R visitPrimitiveAsLong(PrimitiveType t, P p) { |
199 | return defaultAction(t, p); |
200 | } |
201 | |
202 | /** |
203 | * Visits a {@code CHAR} primitive type by calling |
204 | * {@code defaultAction}. |
205 | * |
206 | * @param t the type to visit |
207 | * @param p a visitor-specified parameter |
208 | * @return the result of {@code defaultAction} |
209 | */ |
210 | public R visitPrimitiveAsChar(PrimitiveType t, P p) { |
211 | return defaultAction(t, p); |
212 | } |
213 | |
214 | /** |
215 | * Visits a {@code FLOAT} primitive type by calling |
216 | * {@code defaultAction}. |
217 | * |
218 | * @param t the type to visit |
219 | * @param p a visitor-specified parameter |
220 | * @return the result of {@code defaultAction} |
221 | */ |
222 | public R visitPrimitiveAsFloat(PrimitiveType t, P p) { |
223 | return defaultAction(t, p); |
224 | } |
225 | |
226 | /** |
227 | * Visits a {@code DOUBLE} primitive type by calling |
228 | * {@code defaultAction}. |
229 | * |
230 | * @param t the type to visit |
231 | * @param p a visitor-specified parameter |
232 | * @return the result of {@code defaultAction} |
233 | */ |
234 | public R visitPrimitiveAsDouble(PrimitiveType t, P p) { |
235 | return defaultAction(t, p); |
236 | } |
237 | |
238 | /** |
239 | * Visits a {@link NoType} instance, dispatching to the visit method for |
240 | * the specific {@linkplain TypeKind kind} of pseudo-type: |
241 | * {@code VOID}, {@code PACKAGE}, or {@code NONE}. |
242 | * |
243 | * @param t {@inheritDoc} |
244 | * @param p {@inheritDoc} |
245 | * @return the result of the kind-specific visit method |
246 | */ |
247 | @Override |
248 | public R visitNoType(NoType t, P p) { |
249 | TypeKind k = t.getKind(); |
250 | switch (k) { |
251 | case VOID: |
252 | return visitNoTypeAsVoid(t, p); |
253 | |
254 | case PACKAGE: |
255 | return visitNoTypeAsPackage(t, p); |
256 | |
257 | case NONE: |
258 | return visitNoTypeAsNone(t, p); |
259 | |
260 | default: |
261 | throw new AssertionError("Bad kind " + k + " for NoType" + t); |
262 | } |
263 | } |
264 | |
265 | /** |
266 | * Visits a {@link TypeKind#VOID VOID} pseudo-type by calling |
267 | * {@code defaultAction}. |
268 | * |
269 | * @param t the type to visit |
270 | * @param p a visitor-specified parameter |
271 | * @return the result of {@code defaultAction} |
272 | */ |
273 | public R visitNoTypeAsVoid(NoType t, P p) { |
274 | return defaultAction(t, p); |
275 | } |
276 | |
277 | /** |
278 | * Visits a {@link TypeKind#PACKAGE PACKAGE} pseudo-type by calling |
279 | * {@code defaultAction}. |
280 | * |
281 | * @param t the type to visit |
282 | * @param p a visitor-specified parameter |
283 | * @return the result of {@code defaultAction} |
284 | */ |
285 | public R visitNoTypeAsPackage(NoType t, P p) { |
286 | return defaultAction(t, p); |
287 | } |
288 | |
289 | /** |
290 | * Visits a {@link TypeKind#NONE NONE} pseudo-type by calling |
291 | * {@code defaultAction}. |
292 | * |
293 | * @param t the type to visit |
294 | * @param p a visitor-specified parameter |
295 | * @return the result of {@code defaultAction} |
296 | */ |
297 | public R visitNoTypeAsNone(NoType t, P p) { |
298 | return defaultAction(t, p); |
299 | } |
300 | } |