1 /* 2 * Copyright (c) 2005, 2017, Oracle and/or its affiliates. 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package javax.lang.model.util; 27 28 import javax.annotation.processing.SupportedSourceVersion; 29 import javax.lang.model.SourceVersion; 30 import javax.lang.model.type.*; 31 import static javax.lang.model.SourceVersion.*; 32 33 /** 34 * A visitor of types based on their {@linkplain TypeKind kind} with 35 * default behavior appropriate for the {@link SourceVersion#RELEASE_6 36 * RELEASE_6} source version. For {@linkplain 37 * TypeMirror types} <code><i>Xyz</i></code> that may have more than one 38 * kind, the <code>visit<i>Xyz</i></code> methods in this class delegate 39 * to the <code>visit<i>Xyz</i>As<i>Kind</i></code> method corresponding to the 40 * first argument's kind. The <code>visit<i>Xyz</i>As<i>Kind</i></code> methods 41 * call {@link #defaultAction defaultAction}, passing their arguments 42 * to {@code defaultAction}'s corresponding parameters. 43 * 44 * <p> Methods in this class may be overridden subject to their 45 * general contract. Note that annotating methods in concrete 46 * subclasses with {@link java.lang.Override @Override} will help 47 * ensure that methods are overridden as intended. 48 * 49 * <p> <b>WARNING:</b> The {@code TypeVisitor} interface implemented 50 * by this class may have methods added to it in the future to 51 * accommodate new, currently unknown, language structures added to 52 * future versions of the Java™ programming language. 53 * Therefore, methods whose names begin with {@code "visit"} may be 54 * added to this class in the future; to avoid incompatibilities, 55 * classes which extend this class should not declare any instance 56 * methods with names beginning with {@code "visit"}. 57 * 58 * <p>When such a new visit method is added, the default 59 * implementation in this class will be to call the {@link 60 * #visitUnknown visitUnknown} method. A new type kind visitor class 61 * will also be introduced to correspond to the new language level; 62 * this visitor will have different default behavior for the visit 63 * method in question. When the new visitor is introduced, all or 64 * portions of this visitor may be deprecated. 65 * 66 * @param <R> the return type of this visitor's methods. Use {@link 67 * Void} for visitors that do not need to return results. 68 * @param <P> the type of the additional parameter to this visitor's 69 * methods. Use {@code Void} for visitors that do not need an 70 * additional parameter. 71 * 72 * @author Joseph D. Darcy 73 * @author Scott Seligman 74 * @author Peter von der Ahé 75 * 76 * @see TypeKindVisitor7 77 * @see TypeKindVisitor8 78 * @since 1.6 79 */ 80 @SupportedSourceVersion(RELEASE_6) 81 public class TypeKindVisitor6<R, P> extends SimpleTypeVisitor6<R, P> { 82 /** 83 * Constructor for concrete subclasses to call; uses {@code null} 84 * for the default value. 85 * @deprecated Release 6 is obsolete; update to a visitor for a newer 86 * release level. 87 */ 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 131 case INT: 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 }