88 @Deprecated(since="9")
89 protected TypeKindVisitor6() {
90 super(null);
91 }
92
93
94 /**
95 * Constructor for concrete subclasses to call; uses the argument
96 * for the default value.
97 *
98 * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
99 * @deprecated Release 6 is obsolete; update to a visitor for a newer
100 * release level.
101 */
102 @Deprecated(since="9")
103 protected TypeKindVisitor6(R defaultValue) {
104 super(defaultValue);
105 }
106
107 /**
108 * Visits a primitive type, dispatching to the visit method for
109 * the specific {@linkplain TypeKind kind} of primitive type:
110 * {@code BOOLEAN}, {@code BYTE}, etc.
111 *
112 * @param t {@inheritDoc}
113 * @param p {@inheritDoc}
114 * @return the result of the kind-specific visit method
115 */
116 @Override
117 public R visitPrimitive(PrimitiveType t, P p) {
118 TypeKind k = t.getKind();
119 switch (k) {
120 case BOOLEAN:
121 return visitPrimitiveAsBoolean(t, p);
122
123 case BYTE:
124 return visitPrimitiveAsByte(t, p);
125
126 case SHORT:
127 return visitPrimitiveAsShort(t, p);
128
130 return visitPrimitiveAsInt(t, p);
131
132 case LONG:
133 return visitPrimitiveAsLong(t, p);
134
135 case CHAR:
136 return visitPrimitiveAsChar(t, p);
137
138 case FLOAT:
139 return visitPrimitiveAsFloat(t, p);
140
141 case DOUBLE:
142 return visitPrimitiveAsDouble(t, p);
143
144 default:
145 throw new AssertionError("Bad kind " + k + " for PrimitiveType" + t);
146 }
147 }
148
149 /**
150 * Visits a {@code BOOLEAN} primitive type by calling
151 * {@code defaultAction}.
152 *
153 * @param t the type to visit
154 * @param p a visitor-specified parameter
155 * @return the result of {@code defaultAction}
156 */
157 public R visitPrimitiveAsBoolean(PrimitiveType t, P p) {
158 return defaultAction(t, p);
159 }
160
161 /**
162 * Visits a {@code BYTE} primitive type by calling
163 * {@code defaultAction}.
164 *
165 * @param t the type to visit
166 * @param p a visitor-specified parameter
167 * @return the result of {@code defaultAction}
168 */
169 public R visitPrimitiveAsByte(PrimitiveType t, P p) {
170 return defaultAction(t, p);
171 }
172
173 /**
174 * Visits a {@code SHORT} primitive type by calling
175 * {@code defaultAction}.
176 *
177 * @param t the type to visit
178 * @param p a visitor-specified parameter
179 * @return the result of {@code defaultAction}
180 */
181 public R visitPrimitiveAsShort(PrimitiveType t, P p) {
182 return defaultAction(t, p);
183 }
184
185 /**
186 * Visits an {@code INT} primitive type by calling
187 * {@code defaultAction}.
188 *
189 * @param t the type to visit
190 * @param p a visitor-specified parameter
191 * @return the result of {@code defaultAction}
192 */
193 public R visitPrimitiveAsInt(PrimitiveType t, P p) {
194 return defaultAction(t, p);
195 }
196
197 /**
198 * Visits a {@code LONG} primitive type by calling
199 * {@code defaultAction}.
200 *
201 * @param t the type to visit
202 * @param p a visitor-specified parameter
203 * @return the result of {@code defaultAction}
204 */
205 public R visitPrimitiveAsLong(PrimitiveType t, P p) {
206 return defaultAction(t, p);
207 }
208
209 /**
210 * Visits a {@code CHAR} primitive type by calling
211 * {@code defaultAction}.
212 *
213 * @param t the type to visit
214 * @param p a visitor-specified parameter
215 * @return the result of {@code defaultAction}
216 */
217 public R visitPrimitiveAsChar(PrimitiveType t, P p) {
218 return defaultAction(t, p);
219 }
220
221 /**
222 * Visits a {@code FLOAT} primitive type by calling
223 * {@code defaultAction}.
224 *
225 * @param t the type to visit
226 * @param p a visitor-specified parameter
227 * @return the result of {@code defaultAction}
228 */
229 public R visitPrimitiveAsFloat(PrimitiveType t, P p) {
230 return defaultAction(t, p);
231 }
232
233 /**
234 * Visits a {@code DOUBLE} primitive type by calling
235 * {@code defaultAction}.
236 *
237 * @param t the type to visit
238 * @param p a visitor-specified parameter
239 * @return the result of {@code defaultAction}
240 */
241 public R visitPrimitiveAsDouble(PrimitiveType t, P p) {
242 return defaultAction(t, p);
243 }
244
245 /**
246 * Visits a {@link NoType} instance, dispatching to the visit method for
247 * the specific {@linkplain TypeKind kind} of pseudo-type:
248 * {@code VOID}, {@code PACKAGE}, or {@code NONE}.
249 *
250 * @param t {@inheritDoc}
251 * @param p {@inheritDoc}
252 * @return the result of the kind-specific visit method
253 */
254 @Override
255 public R visitNoType(NoType t, P p) {
256 TypeKind k = t.getKind();
257 switch (k) {
258 case VOID:
259 return visitNoTypeAsVoid(t, p);
260
261 case PACKAGE:
262 return visitNoTypeAsPackage(t, p);
263
264 case NONE:
265 return visitNoTypeAsNone(t, p);
266
267 default:
268 throw new AssertionError("Bad kind " + k + " for NoType" + t);
269 }
270 }
271
272 /**
273 * Visits a {@link TypeKind#VOID VOID} pseudo-type by calling
274 * {@code defaultAction}.
275 *
276 * @param t the type to visit
277 * @param p a visitor-specified parameter
278 * @return the result of {@code defaultAction}
279 */
280 public R visitNoTypeAsVoid(NoType t, P p) {
281 return defaultAction(t, p);
282 }
283
284 /**
285 * Visits a {@link TypeKind#PACKAGE PACKAGE} pseudo-type by calling
286 * {@code defaultAction}.
287 *
288 * @param t the type to visit
289 * @param p a visitor-specified parameter
290 * @return the result of {@code defaultAction}
291 */
292 public R visitNoTypeAsPackage(NoType t, P p) {
293 return defaultAction(t, p);
294 }
295
296 /**
297 * Visits a {@link TypeKind#NONE NONE} pseudo-type by calling
298 * {@code defaultAction}.
299 *
300 * @param t the type to visit
301 * @param p a visitor-specified parameter
302 * @return the result of {@code defaultAction}
303 */
304 public R visitNoTypeAsNone(NoType t, P p) {
305 return defaultAction(t, p);
306 }
307 }
|
88 @Deprecated(since="9")
89 protected TypeKindVisitor6() {
90 super(null);
91 }
92
93
94 /**
95 * Constructor for concrete subclasses to call; uses the argument
96 * for the default value.
97 *
98 * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
99 * @deprecated Release 6 is obsolete; update to a visitor for a newer
100 * release level.
101 */
102 @Deprecated(since="9")
103 protected TypeKindVisitor6(R defaultValue) {
104 super(defaultValue);
105 }
106
107 /**
108 * {@inheritDoc}
109 *
110 * @implSpec This implementation dispatches to the visit method for
111 * the specific {@linkplain TypeKind kind} of primitive type:
112 * {@code BOOLEAN}, {@code BYTE}, etc.
113 *
114 * @param t {@inheritDoc}
115 * @param p {@inheritDoc}
116 * @return the result of the kind-specific visit method
117 */
118 @Override
119 public R visitPrimitive(PrimitiveType t, P p) {
120 TypeKind k = t.getKind();
121 switch (k) {
122 case BOOLEAN:
123 return visitPrimitiveAsBoolean(t, p);
124
125 case BYTE:
126 return visitPrimitiveAsByte(t, p);
127
128 case SHORT:
129 return visitPrimitiveAsShort(t, p);
130
132 return visitPrimitiveAsInt(t, p);
133
134 case LONG:
135 return visitPrimitiveAsLong(t, p);
136
137 case CHAR:
138 return visitPrimitiveAsChar(t, p);
139
140 case FLOAT:
141 return visitPrimitiveAsFloat(t, p);
142
143 case DOUBLE:
144 return visitPrimitiveAsDouble(t, p);
145
146 default:
147 throw new AssertionError("Bad kind " + k + " for PrimitiveType" + t);
148 }
149 }
150
151 /**
152 * Visits a {@code BOOLEAN} primitive type.
153 *
154 * @implSpec This implementation calls {@code defaultAction}.
155 *
156 * @param t the type to visit
157 * @param p a visitor-specified parameter
158 * @return the result of {@code defaultAction}
159 */
160 public R visitPrimitiveAsBoolean(PrimitiveType t, P p) {
161 return defaultAction(t, p);
162 }
163
164 /**
165 * Visits a {@code BYTE} primitive type.
166 *
167 * @implSpec This implementation calls {@code defaultAction}.
168 *
169 * @param t the type to visit
170 * @param p a visitor-specified parameter
171 * @return the result of {@code defaultAction}
172 */
173 public R visitPrimitiveAsByte(PrimitiveType t, P p) {
174 return defaultAction(t, p);
175 }
176
177 /**
178 * Visits a {@code SHORT} primitive type.
179 *
180 * @implSpec This implementation calls {@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 visitPrimitiveAsShort(PrimitiveType t, P p) {
187 return defaultAction(t, p);
188 }
189
190 /**
191 * Visits an {@code INT} primitive type.
192 *
193 * @implSpec This implementation calls {@code defaultAction}.
194 *
195 * @param t the type to visit
196 * @param p a visitor-specified parameter
197 * @return the result of {@code defaultAction}
198 */
199 public R visitPrimitiveAsInt(PrimitiveType t, P p) {
200 return defaultAction(t, p);
201 }
202
203 /**
204 * Visits a {@code LONG} primitive type.
205 *
206 * @implSpec This implementation calls {@code defaultAction}.
207 *
208 * @param t the type to visit
209 * @param p a visitor-specified parameter
210 * @return the result of {@code defaultAction}
211 */
212 public R visitPrimitiveAsLong(PrimitiveType t, P p) {
213 return defaultAction(t, p);
214 }
215
216 /**
217 * Visits a {@code CHAR} primitive type.
218 *
219 * @implSpec This implementation calls {@code defaultAction}.
220 *
221 * @param t the type to visit
222 * @param p a visitor-specified parameter
223 * @return the result of {@code defaultAction}
224 */
225 public R visitPrimitiveAsChar(PrimitiveType t, P p) {
226 return defaultAction(t, p);
227 }
228
229 /**
230 * Visits a {@code FLOAT} primitive type.
231 *
232 * @implSpec This implementation calls {@code defaultAction}.
233 *
234 * @param t the type to visit
235 * @param p a visitor-specified parameter
236 * @return the result of {@code defaultAction}
237 */
238 public R visitPrimitiveAsFloat(PrimitiveType t, P p) {
239 return defaultAction(t, p);
240 }
241
242 /**
243 * Visits a {@code DOUBLE} primitive type.
244 *
245 * @implSpec This implementation calls {@code defaultAction}.
246 *
247 * @param t the type to visit
248 * @param p a visitor-specified parameter
249 * @return the result of {@code defaultAction}
250 */
251 public R visitPrimitiveAsDouble(PrimitiveType t, P p) {
252 return defaultAction(t, p);
253 }
254
255 /**
256 * {@inheritDoc}
257 *
258 * @implSpec This implementation dispatches to the visit method for
259 * the specific {@linkplain TypeKind kind} of pseudo-type:
260 * {@code VOID}, {@code PACKAGE}, or {@code NONE}.
261 *
262 * @param t {@inheritDoc}
263 * @param p {@inheritDoc}
264 * @return the result of the kind-specific visit method
265 */
266 @Override
267 public R visitNoType(NoType t, P p) {
268 TypeKind k = t.getKind();
269 switch (k) {
270 case VOID:
271 return visitNoTypeAsVoid(t, p);
272
273 case PACKAGE:
274 return visitNoTypeAsPackage(t, p);
275
276 case NONE:
277 return visitNoTypeAsNone(t, p);
278
279 default:
280 throw new AssertionError("Bad kind " + k + " for NoType" + t);
281 }
282 }
283
284 /**
285 * Visits a {@link TypeKind#VOID VOID} pseudo-type.
286 *
287 * @implSpec This implementation calls {@code defaultAction}.
288 *
289 * @param t the type to visit
290 * @param p a visitor-specified parameter
291 * @return the result of {@code defaultAction}
292 */
293 public R visitNoTypeAsVoid(NoType t, P p) {
294 return defaultAction(t, p);
295 }
296
297 /**
298 * Visits a {@link TypeKind#PACKAGE PACKAGE} pseudo-type.
299 *
300 * @implSpec This implementation calls {@code defaultAction}.
301 *
302 * @param t the type to visit
303 * @param p a visitor-specified parameter
304 * @return the result of {@code defaultAction}
305 */
306 public R visitNoTypeAsPackage(NoType t, P p) {
307 return defaultAction(t, p);
308 }
309
310 /**
311 * Visits a {@link TypeKind#NONE NONE} pseudo-type.
312 *
313 * @implSpec This implementation calls {@code defaultAction}.
314 *
315 * @param t the type to visit
316 * @param p a visitor-specified parameter
317 * @return the result of {@code defaultAction}
318 */
319 public R visitNoTypeAsNone(NoType t, P p) {
320 return defaultAction(t, p);
321 }
322 }
|