EMMA Coverage Report (generated Thu Dec 06 15:52:10 GMT 2007)
[all classes][javax.lang.model.util]

COVERAGE SUMMARY FOR SOURCE FILE [SimpleAnnotationValueVisitor6.java]

nameclass, %method, %block, %line, %
SimpleAnnotationValueVisitor6.java0%   (0/1)0%   (0/16)0%   (0/88)0%   (0/20)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class SimpleAnnotationValueVisitor60%   (0/1)0%   (0/16)0%   (0/88)0%   (0/20)
SimpleAnnotationValueVisitor6 (): void 0%   (0/1)0%   (0/6)0%   (0/3)
SimpleAnnotationValueVisitor6 (Object): void 0%   (0/1)0%   (0/6)0%   (0/3)
defaultAction (Object, Object): Object 0%   (0/1)0%   (0/3)0%   (0/1)
visitAnnotation (AnnotationMirror, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitArray (List, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitBoolean (boolean, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitByte (byte, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitChar (char, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitDouble (double, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitEnumConstant (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitFloat (float, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitInt (int, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitLong (long, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitShort (short, Object): Object 0%   (0/1)0%   (0/6)0%   (0/1)
visitString (String, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitType (TypeMirror, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)

1/*
2 * Copyright 2005-2006 Sun Microsystems, Inc.  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.  Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any 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 * @since 1.6
73 */
74@SupportedSourceVersion(RELEASE_6)
75public 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}

[all classes][javax.lang.model.util]
EMMA 2.0.5312 (C) Vladimir Roubtsov