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