001: /*
002: * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package javax.lang.model.util;
027:
028: import java.util.List;
029: import javax.lang.model.element.*;
030:
031: import javax.lang.model.type.TypeMirror;
032: import static javax.lang.model.SourceVersion.*;
033: import javax.lang.model.SourceVersion;
034: import javax.annotation.processing.SupportedSourceVersion;
035:
036: /**
037: * A simple visitor for annotation values with default behavior
038: * appropriate for the {@link SourceVersion#RELEASE_6 RELEASE_6}
039: * source version. Visit methods call {@link
040: * #defaultAction} passing their arguments to {@code defaultAction}'s
041: * corresponding parameters.
042: *
043: * <p> Methods in this class may be overridden subject to their
044: * general contract. Note that annotating methods in concrete
045: * subclasses with {@link java.lang.Override @Override} will help
046: * ensure that methods are overridden as intended.
047: *
048: * <p> <b>WARNING:</b> The {@code AnnotationValueVisitor} interface
049: * implemented by this class may have methods added to it in the
050: * future to accommodate new, currently unknown, language structures
051: * added to future versions of the Java™ programming language.
052: * Therefore, methods whose names begin with {@code "visit"} may be
053: * added to this class in the future; to avoid incompatibilities,
054: * classes which extend this class should not declare any instance
055: * methods with names beginning with {@code "visit"}.
056: *
057: * <p>When such a new visit method is added, the default
058: * implementation in this class will be to call the {@link
059: * #visitUnknown visitUnknown} method. A new simple annotation
060: * value visitor class will also be introduced to correspond to the
061: * new language level; this visitor will have different default
062: * behavior for the visit method in question. When the new visitor is
063: * introduced, all or portions of this visitor may be deprecated.
064: *
065: * @param <R> the return type of this visitor's methods
066: * @param <P> the type of the additional parameter to this visitor's methods.
067: *
068: * @author Joseph D. Darcy
069: * @author Scott Seligman
070: * @author Peter von der Ahé
071: * @version 1.12 07/05/05
072: * @since 1.6
073: */
074: @SupportedSourceVersion(RELEASE_6)
075: public class SimpleAnnotationValueVisitor6<R, P> extends
076: AbstractAnnotationValueVisitor6<R, P> {
077:
078: /**
079: * Default value to be returned; {@link #defaultAction
080: * defaultAction} returns this value unless the method is
081: * overridden.
082: */
083: protected final R DEFAULT_VALUE;
084:
085: /**
086: * Constructor for concrete subclasses; uses {@code null} for the
087: * default value.
088: */
089: protected SimpleAnnotationValueVisitor6() {
090: super ();
091: DEFAULT_VALUE = null;
092: }
093:
094: /**
095: * Constructor for concrete subclasses; uses the argument for the
096: * default value.
097: *
098: * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
099: */
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: }
|