1   /*
    2    * Copyright (c) 2005, 2010, 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 skeletal visitor for annotation values with default behavior
   39    * appropriate for the {@link SourceVersion#RELEASE_6 RELEASE_6}
   40    * source version.
   41    *
   42    * <p> <b>WARNING:</b> The {@code AnnotationValueVisitor} interface
   43    * implemented by this class may have methods added to it in the
   44    * future to accommodate new, currently unknown, language structures
   45    * added to future versions of the Java&trade; programming language.
   46    * Therefore, methods whose names begin with {@code "visit"} may be
   47    * added to this class in the future; to avoid incompatibilities,
   48    * classes which extend this class should not declare any instance
   49    * methods with names beginning with {@code "visit"}.
   50    *
   51    * <p>When such a new visit method is added, the default
   52    * implementation in this class will be to call the {@link
   53    * #visitUnknown visitUnknown} method.  A new abstract annotation
   54    * value visitor class will also be introduced to correspond to the
   55    * new language level; this visitor will have different default
   56    * behavior for the visit method in question.  When the new visitor is
   57    * introduced, all or portions of this visitor may be deprecated.
   58    *
   59    * @param <R> the return type of this visitor's methods
   60    * @param <P> the type of the additional parameter to this visitor's methods.
   61    *
   62    * @author Joseph D. Darcy
   63    * @author Scott Seligman
   64    * @author Peter von der Ah&eacute;
   65    *
   66    * @see AbstractAnnotationValueVisitor7
   67    * @since 1.6
   68    */
   69   @SupportedSourceVersion(RELEASE_6)
   70   public abstract class AbstractAnnotationValueVisitor6<R, P>
   71       implements AnnotationValueVisitor<R, P> {
   72   
   73       /**
   74        * Constructor for concrete subclasses to call.
   75        */
   76       protected AbstractAnnotationValueVisitor6() {}
   77   
   78       /**
   79        * Visits an annotation value as if by passing itself to that
   80        * value's {@link AnnotationValue#accept accept}.  The invocation
   81        * {@code v.visit(av)} is equivalent to {@code av.accept(v, p)}.
   82        * @param av {@inheritDoc}
   83        * @param p  {@inheritDoc}
   84        */
   85       public final R visit(AnnotationValue av, P p) {
   86           return av.accept(this, p);
   87       }
   88   
   89       /**
   90        * Visits an annotation value as if by passing itself to that
   91        * value's {@link AnnotationValue#accept accept} method passing
   92        * {@code null} for the additional parameter.  The invocation
   93        * {@code v.visit(av)} is equivalent to {@code av.accept(v,
   94        * null)}.
   95        * @param av {@inheritDoc}
   96        */
   97       public final R visit(AnnotationValue av) {
   98           return av.accept(this, null);
   99       }
  100   
  101       /**
  102        * {@inheritDoc}
  103        *
  104        * <p>The default implementation of this method in {@code
  105        * AbstractAnnotationValueVisitor6} will always throw {@code
  106        * UnknownAnnotationValueException}.  This behavior is not
  107        * required of a subclass.
  108        *
  109        * @param av {@inheritDoc}
  110        * @param p  {@inheritDoc}
  111        */
  112       public R visitUnknown(AnnotationValue av, P p) {
  113           throw new UnknownAnnotationValueException(av, p);
  114       }
  115   }