--- /dev/null 2009-07-06 20:02:10.000000000 -0700 +++ new/src/share/classes/javax/lang/model/util/SharedElementKindVisitor.java 2010-04-29 22:39:16.000000000 -0700 @@ -0,0 +1,347 @@ +/* + * Copyright 2010 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +package javax.lang.model.util; + +import javax.lang.model.element.*; +import static javax.lang.model.element.ElementKind.*; +import javax.annotation.processing.SupportedSourceVersion; +import static javax.lang.model.SourceVersion.*; +import javax.lang.model.SourceVersion; + + +/** + * Shared package private superclass to reduce code bloat. + * + * @param the return type of this visitor's methods. Use {@link + * Void} for visitors that do not need to return results. + * @param

the type of the additional parameter to this visitor's + * methods. Use {@code Void} for visitors that do not need an + * additional parameter. + * + * @since 1.7 + */ +class SharedElementKindVisitor extends SimpleElementVisitor6 { + /** + * Constructor for concrete subclasses; uses {@code null} for the + * default value. + */ + protected SharedElementKindVisitor() { + super(null); + } + + /** + * Constructor for concrete subclasses; uses the argument for the + * default value. + * + * @param defaultValue the value to assign to {@link #DEFAULT_VALUE} + */ + protected SharedElementKindVisitor(R defaultValue) { + super(defaultValue); + } + + /** + * {@inheritDoc} + * + * The element argument has kind {@code PACKAGE}. + * + * @param e {@inheritDoc} + * @param p {@inheritDoc} + * @return {@inheritDoc} + */ + @Override + public R visitPackage(PackageElement e, P p) { + assert e.getKind() == PACKAGE: "Bad kind on PackageElement"; + return defaultAction(e, p); + } + + /** + * Visits a type element, dispatching to the visit method for the + * specific {@linkplain ElementKind kind} of type, {@code + * ANNOTATION_TYPE}, {@code CLASS}, {@code ENUM}, or {@code + * INTERFACE}. + * + * @param e {@inheritDoc} + * @param p {@inheritDoc} + * @return the result of the kind-specific visit method + */ + @Override + public R visitType(TypeElement e, P p) { + ElementKind k = e.getKind(); + switch(k) { + case ANNOTATION_TYPE: + return visitTypeAsAnnotationType(e, p); + + case CLASS: + return visitTypeAsClass(e, p); + + case ENUM: + return visitTypeAsEnum(e, p); + + case INTERFACE: + return visitTypeAsInterface(e, p); + + default: + throw new AssertionError("Bad kind " + k + " for TypeElement" + e); + } + } + + /** + * Visits an {@code ANNOTATION_TYPE} type element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitTypeAsAnnotationType(TypeElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code CLASS} type element by calling {@code + * defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitTypeAsClass(TypeElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits an {@code ENUM} type element by calling {@code + * defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitTypeAsEnum(TypeElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits an {@code INTERFACE} type element by calling {@code + * defaultAction}. + *. + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitTypeAsInterface(TypeElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a variable element, dispatching to the visit method for + * the specific {@linkplain ElementKind kind} of variable, {@code + * ENUM_CONSTANT}, {@code EXCEPTION_PARAMETER}, {@code FIELD}, + * {@code LOCAL_VARIABLE}, or {@code PARAMETER}. + * @param e {@inheritDoc} + * @param p {@inheritDoc} + * @return the result of the kind-specific visit method + */ + @Override + public R visitVariable(VariableElement e, P p) { + ElementKind k = e.getKind(); + switch(k) { + case ENUM_CONSTANT: + return visitVariableAsEnumConstant(e, p); + + case EXCEPTION_PARAMETER: + return visitVariableAsExceptionParameter(e, p); + + case FIELD: + return visitVariableAsField(e, p); + + case LOCAL_VARIABLE: + return visitVariableAsLocalVariable(e, p); + + case PARAMETER: + return visitVariableAsParameter(e, p); + + default: + throw new AssertionError("Bad kind " + k + " for VariableElement" + e); + } + + } + + /** + * Visits an {@code ENUM_CONSTANT} variable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitVariableAsEnumConstant(VariableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits an {@code EXCEPTION_PARAMETER} variable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitVariableAsExceptionParameter(VariableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code FIELD} variable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitVariableAsField(VariableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code LOCAL_VARIABLE} variable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitVariableAsLocalVariable(VariableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code PARAMETER} variable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitVariableAsParameter(VariableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits an executable element, dispatching to the visit method + * for the specific {@linkplain ElementKind kind} of executable, + * {@code CONSTRUCTOR}, {@code INSTANCE_INIT}, {@code METHOD}, or + * {@code STATIC_INIT}. + * + * @param e {@inheritDoc} + * @param p {@inheritDoc} + * @return the result of the kind-specific visit method + */ + @Override + public R visitExecutable(ExecutableElement e, P p) { + ElementKind k = e.getKind(); + switch(k) { + case CONSTRUCTOR: + return visitExecutableAsConstructor(e, p); + + case INSTANCE_INIT: + return visitExecutableAsInstanceInit(e, p); + + case METHOD: + return visitExecutableAsMethod(e, p); + + case STATIC_INIT: + return visitExecutableAsStaticInit(e, p); + + default: + throw new AssertionError("Bad kind " + k + " for ExecutableElement" + e); + } + } + + /** + * Visits a {@code CONSTRUCTOR} executable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitExecutableAsConstructor(ExecutableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits an {@code INSTANCE_INIT} executable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitExecutableAsInstanceInit(ExecutableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code METHOD} executable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitExecutableAsMethod(ExecutableElement e, P p) { + return defaultAction(e, p); + } + + /** + * Visits a {@code STATIC_INIT} executable element by calling + * {@code defaultAction}. + * + * @param e the element to visit + * @param p a visitor-specified parameter + * @return the result of {@code defaultAction} + */ + public R visitExecutableAsStaticInit(ExecutableElement e, P p) { + return defaultAction(e, p); + } + + + /** + * {@inheritDoc} + * + * The element argument has kind {@code TYPE_PARAMETER}. + * + * @param e {@inheritDoc} + * @param p {@inheritDoc} + * @return {@inheritDoc} + */ + @Override + public R visitTypeParameter(TypeParameterElement e, P p) { + assert e.getKind() == TYPE_PARAMETER: "Bad kind on TypeParameterElement"; + return defaultAction(e, p); + } +}