1 /*
   2  * Copyright (c) 2005, 2006, 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 
  29 import java.util.List;
  30 import javax.lang.model.element.*;
  31 
  32 import javax.lang.model.type.TypeMirror;
  33 import static javax.lang.model.SourceVersion.*;
  34 import javax.lang.model.SourceVersion;
  35 import javax.annotation.processing.SupportedSourceVersion;
  36 
  37 /**
  38  * A simple visitor for annotation values with default behavior
  39  * appropriate for the {@link SourceVersion#RELEASE_6 RELEASE_6}
  40  * source version.  Visit methods call {@link
  41  * #defaultAction} passing their arguments to {@code defaultAction}'s
  42  * 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 AnnotationValueVisitor} interface
  50  * implemented by this class may have methods added to it in the
  51  * future to accommodate new, currently unknown, language structures
  52  * added to future versions of the Java&trade; 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 simple annotation
  61  * value visitor class will also be introduced to correspond to the
  62  * new language level; this visitor will have different default
  63  * behavior for the visit method in question.  When the new visitor is
  64  * introduced, all or portions of this visitor may be deprecated.
  65  *
  66  * @param <R> the return type of this visitor's methods
  67  * @param <P> the type of the additional parameter to this visitor's methods.
  68  *
  69  * @author Joseph D. Darcy
  70  * @author Scott Seligman
  71  * @author Peter von der Ah&eacute;
  72  * @since 1.6
  73  */
  74 @SupportedSourceVersion(RELEASE_6)
  75 public class SimpleAnnotationValueVisitor6<R, P>
  76     extends AbstractAnnotationValueVisitor6<R, P> {
  77 
  78     /**
  79      * Default value to be returned; {@link #defaultAction
  80      * defaultAction} returns this value unless the method is
  81      * overridden.
  82      */
  83     protected final R DEFAULT_VALUE;
  84 
  85     /**
  86      * Constructor for concrete subclasses; uses {@code null} for the
  87      * default value.
  88      */
  89     protected SimpleAnnotationValueVisitor6() {
  90         super();
  91         DEFAULT_VALUE = null;
  92     }
  93 
  94     /**
  95      * Constructor for concrete subclasses; uses the argument for the
  96      * default value.
  97      *
  98      * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
  99      */
 100     protected SimpleAnnotationValueVisitor6(R defaultValue) {
 101         super();
 102         DEFAULT_VALUE = defaultValue;
 103     }
 104 
 105     /**
 106      * The default action for visit methods.  The implementation in
 107      * this class just returns {@link #DEFAULT_VALUE}; subclasses will
 108      * commonly override this method.
 109      *
 110      * @param o the value of the annotation
 111      * @param p a visitor-specified parameter
 112      * @return {@code DEFAULT_VALUE} unless overridden
 113      */
 114     protected R defaultAction(Object o, P p) {
 115         return DEFAULT_VALUE;
 116     }
 117 
 118     /**
 119      * {@inheritDoc} This implementation calls {@code defaultAction}.
 120      *
 121      * @param b {@inheritDoc}
 122      * @param p {@inheritDoc}
 123      * @return  the result of {@code defaultAction}
 124      */
 125     public R visitBoolean(boolean b, P p) {
 126         return defaultAction(b, p);
 127     }
 128 
 129     /**
 130      * {@inheritDoc} This implementation calls {@code defaultAction}.
 131      *
 132      * @param b {@inheritDoc}
 133      * @param p {@inheritDoc}
 134      * @return  the result of {@code defaultAction}
 135      */
 136     public R visitByte(byte b, P p) {
 137         return defaultAction(b, p);
 138     }
 139 
 140     /**
 141      * {@inheritDoc} This implementation calls {@code defaultAction}.
 142      *
 143      * @param c {@inheritDoc}
 144      * @param p {@inheritDoc}
 145      * @return  the result of {@code defaultAction}
 146      */
 147     public R visitChar(char c, P p) {
 148         return defaultAction(c, p);
 149     }
 150 
 151     /**
 152      * {@inheritDoc} This implementation calls {@code defaultAction}.
 153      *
 154      * @param d {@inheritDoc}
 155      * @param p {@inheritDoc}
 156      * @return  the result of {@code defaultAction}
 157      */
 158     public R visitDouble(double d, P p) {
 159         return defaultAction(d, p);
 160     }
 161 
 162     /**
 163      * {@inheritDoc} This implementation calls {@code defaultAction}.
 164      *
 165      * @param f {@inheritDoc}
 166      * @param p {@inheritDoc}
 167      * @return  the result of {@code defaultAction}
 168      */
 169     public R visitFloat(float f, P p) {
 170         return defaultAction(f, p);
 171     }
 172 
 173     /**
 174      * {@inheritDoc} This implementation calls {@code defaultAction}.
 175      *
 176      * @param i {@inheritDoc}
 177      * @param p {@inheritDoc}
 178      * @return  the result of {@code defaultAction}
 179      */
 180     public R visitInt(int i, P p) {
 181         return defaultAction(i, p);
 182     }
 183 
 184     /**
 185      * {@inheritDoc} This implementation calls {@code defaultAction}.
 186      *
 187      * @param i {@inheritDoc}
 188      * @param p {@inheritDoc}
 189      * @return  the result of {@code defaultAction}
 190      */
 191     public R visitLong(long i, P p) {
 192         return defaultAction(i, p);
 193     }
 194 
 195     /**
 196      * {@inheritDoc} This implementation calls {@code defaultAction}.
 197      *
 198      * @param s {@inheritDoc}
 199      * @param p {@inheritDoc}
 200      * @return  the result of {@code defaultAction}
 201      */
 202     public R visitShort(short s, P p) {
 203         return defaultAction(s, p);
 204     }
 205 
 206     /**
 207      * {@inheritDoc} This implementation calls {@code defaultAction}.
 208      *
 209      * @param s {@inheritDoc}
 210      * @param p {@inheritDoc}
 211      * @return  the result of {@code defaultAction}
 212      */
 213     public R visitString(String s, P p) {
 214         return defaultAction(s, p);
 215     }
 216 
 217     /**
 218      * {@inheritDoc} This implementation calls {@code defaultAction}.
 219      *
 220      * @param t {@inheritDoc}
 221      * @param p {@inheritDoc}
 222      * @return  the result of {@code defaultAction}
 223      */
 224     public R visitType(TypeMirror t, P p) {
 225         return defaultAction(t, p);
 226     }
 227 
 228     /**
 229      * {@inheritDoc} This implementation calls {@code defaultAction}.
 230      *
 231      * @param c {@inheritDoc}
 232      * @param p {@inheritDoc}
 233      * @return  the result of {@code defaultAction}
 234      */
 235     public R visitEnumConstant(VariableElement c, P p) {
 236         return defaultAction(c, p);
 237     }
 238 
 239     /**
 240      * {@inheritDoc} This implementation calls {@code defaultAction}.
 241      *
 242      * @param a {@inheritDoc}
 243      * @param p {@inheritDoc}
 244      * @return  the result of {@code defaultAction}
 245      */
 246     public R visitAnnotation(AnnotationMirror a, P p) {
 247         return defaultAction(a, p);
 248     }
 249 
 250     /**
 251      * {@inheritDoc} This implementation calls {@code defaultAction}.
 252      *
 253      * @param vals {@inheritDoc}
 254      * @param p {@inheritDoc}
 255      * @return  the result of {@code defaultAction}
 256      */
 257     public R visitArray(List<? extends AnnotationValue> vals, P p) {
 258         return defaultAction(vals, p);
 259     }
 260 }