1 /*
   2  * Copyright (c) 2005, 2011, 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  *
  73  * @see SimpleAnnotationValueVisitor7
  74  * @see SimpleAnnotationValueVisitor8
  75  * @since 1.6
  76  */
  77 @SupportedSourceVersion(RELEASE_6)
  78 public class SimpleAnnotationValueVisitor6<R, P>
  79     extends AbstractAnnotationValueVisitor6<R, P> {
  80 
  81     /**
  82      * Default value to be returned; {@link #defaultAction
  83      * defaultAction} returns this value unless the method is
  84      * overridden.
  85      */
  86     protected final R DEFAULT_VALUE;
  87 
  88     /**
  89      * Constructor for concrete subclasses; uses {@code null} for the
  90      * default value.
  91      */
  92     protected SimpleAnnotationValueVisitor6() {
  93         super();
  94         DEFAULT_VALUE = null;
  95     }
  96 
  97     /**
  98      * Constructor for concrete subclasses; uses the argument for the
  99      * default value.
 100      *
 101      * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
 102      */
 103     protected SimpleAnnotationValueVisitor6(R defaultValue) {
 104         super();
 105         DEFAULT_VALUE = defaultValue;
 106     }
 107 
 108     /**
 109      * The default action for visit methods.  The implementation in
 110      * this class just returns {@link #DEFAULT_VALUE}; subclasses will
 111      * commonly override this method.
 112      *
 113      * @param o the value of the annotation
 114      * @param p a visitor-specified parameter
 115      * @return {@code DEFAULT_VALUE} unless overridden
 116      */
 117     protected R defaultAction(Object o, P p) {
 118         return DEFAULT_VALUE;
 119     }
 120 
 121     /**
 122      * {@inheritDoc} This implementation calls {@code defaultAction}.
 123      *
 124      * @param b {@inheritDoc}
 125      * @param p {@inheritDoc}
 126      * @return  the result of {@code defaultAction}
 127      */
 128     public R visitBoolean(boolean b, P p) {
 129         return defaultAction(b, p);
 130     }
 131 
 132     /**
 133      * {@inheritDoc} This implementation calls {@code defaultAction}.
 134      *
 135      * @param b {@inheritDoc}
 136      * @param p {@inheritDoc}
 137      * @return  the result of {@code defaultAction}
 138      */
 139     public R visitByte(byte b, P p) {
 140         return defaultAction(b, p);
 141     }
 142 
 143     /**
 144      * {@inheritDoc} This implementation calls {@code defaultAction}.
 145      *
 146      * @param c {@inheritDoc}
 147      * @param p {@inheritDoc}
 148      * @return  the result of {@code defaultAction}
 149      */
 150     public R visitChar(char c, P p) {
 151         return defaultAction(c, p);
 152     }
 153 
 154     /**
 155      * {@inheritDoc} This implementation calls {@code defaultAction}.
 156      *
 157      * @param d {@inheritDoc}
 158      * @param p {@inheritDoc}
 159      * @return  the result of {@code defaultAction}
 160      */
 161     public R visitDouble(double d, P p) {
 162         return defaultAction(d, p);
 163     }
 164 
 165     /**
 166      * {@inheritDoc} This implementation calls {@code defaultAction}.
 167      *
 168      * @param f {@inheritDoc}
 169      * @param p {@inheritDoc}
 170      * @return  the result of {@code defaultAction}
 171      */
 172     public R visitFloat(float f, P p) {
 173         return defaultAction(f, p);
 174     }
 175 
 176     /**
 177      * {@inheritDoc} This implementation calls {@code defaultAction}.
 178      *
 179      * @param i {@inheritDoc}
 180      * @param p {@inheritDoc}
 181      * @return  the result of {@code defaultAction}
 182      */
 183     public R visitInt(int i, P p) {
 184         return defaultAction(i, p);
 185     }
 186 
 187     /**
 188      * {@inheritDoc} This implementation calls {@code defaultAction}.
 189      *
 190      * @param i {@inheritDoc}
 191      * @param p {@inheritDoc}
 192      * @return  the result of {@code defaultAction}
 193      */
 194     public R visitLong(long i, P p) {
 195         return defaultAction(i, p);
 196     }
 197 
 198     /**
 199      * {@inheritDoc} This implementation calls {@code defaultAction}.
 200      *
 201      * @param s {@inheritDoc}
 202      * @param p {@inheritDoc}
 203      * @return  the result of {@code defaultAction}
 204      */
 205     public R visitShort(short s, P p) {
 206         return defaultAction(s, p);
 207     }
 208 
 209     /**
 210      * {@inheritDoc} This implementation calls {@code defaultAction}.
 211      *
 212      * @param s {@inheritDoc}
 213      * @param p {@inheritDoc}
 214      * @return  the result of {@code defaultAction}
 215      */
 216     public R visitString(String s, P p) {
 217         return defaultAction(s, p);
 218     }
 219 
 220     /**
 221      * {@inheritDoc} This implementation calls {@code defaultAction}.
 222      *
 223      * @param t {@inheritDoc}
 224      * @param p {@inheritDoc}
 225      * @return  the result of {@code defaultAction}
 226      */
 227     public R visitType(TypeMirror t, P p) {
 228         return defaultAction(t, p);
 229     }
 230 
 231     /**
 232      * {@inheritDoc} This implementation calls {@code defaultAction}.
 233      *
 234      * @param c {@inheritDoc}
 235      * @param p {@inheritDoc}
 236      * @return  the result of {@code defaultAction}
 237      */
 238     public R visitEnumConstant(VariableElement c, P p) {
 239         return defaultAction(c, p);
 240     }
 241 
 242     /**
 243      * {@inheritDoc} This implementation calls {@code defaultAction}.
 244      *
 245      * @param a {@inheritDoc}
 246      * @param p {@inheritDoc}
 247      * @return  the result of {@code defaultAction}
 248      */
 249     public R visitAnnotation(AnnotationMirror a, P p) {
 250         return defaultAction(a, p);
 251     }
 252 
 253     /**
 254      * {@inheritDoc} This implementation calls {@code defaultAction}.
 255      *
 256      * @param vals {@inheritDoc}
 257      * @param p {@inheritDoc}
 258      * @return  the result of {@code defaultAction}
 259      */
 260     public R visitArray(List<? extends AnnotationValue> vals, P p) {
 261         return defaultAction(vals, p);
 262     }
 263 }