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

COVERAGE SUMMARY FOR SOURCE FILE [ElementKindVisitor6.java]

nameclass, %method, %block, %line, %
ElementKindVisitor6.java0%   (0/2)0%   (0/22)0%   (0/346)0%   (0/44)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ElementKindVisitor60%   (0/1)0%   (0/21)0%   (0/250)0%   (0/44)
<static initializer> 0%   (0/1)0%   (0/8)0%   (0/1)
ElementKindVisitor6 (): void 0%   (0/1)0%   (0/4)0%   (0/2)
ElementKindVisitor6 (Object): void 0%   (0/1)0%   (0/4)0%   (0/2)
visitExecutable (ExecutableElement, Object): Object 0%   (0/1)0%   (0/44)0%   (0/7)
visitExecutableAsConstructor (ExecutableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitExecutableAsInstanceInit (ExecutableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitExecutableAsMethod (ExecutableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitExecutableAsStaticInit (ExecutableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitPackage (PackageElement, Object): Object 0%   (0/1)0%   (0/16)0%   (0/2)
visitType (TypeElement, Object): Object 0%   (0/1)0%   (0/44)0%   (0/7)
visitTypeAsAnnotationType (TypeElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitTypeAsClass (TypeElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitTypeAsEnum (TypeElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitTypeAsInterface (TypeElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitTypeParameter (TypeParameterElement, Object): Object 0%   (0/1)0%   (0/16)0%   (0/2)
visitVariable (VariableElement, Object): Object 0%   (0/1)0%   (0/49)0%   (0/8)
visitVariableAsEnumConstant (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitVariableAsExceptionParameter (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitVariableAsField (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitVariableAsLocalVariable (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
visitVariableAsParameter (VariableElement, Object): Object 0%   (0/1)0%   (0/5)0%   (0/1)
     
class ElementKindVisitor6$10%   (0/1)0%   (0/1)0%   (0/96)0%   (0/1)
<static initializer> 0%   (0/1)0%   (0/96)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 
28import javax.lang.model.element.*;
29import static javax.lang.model.element.ElementKind.*;
30import javax.annotation.processing.SupportedSourceVersion;
31import static javax.lang.model.SourceVersion.*;
32import javax.lang.model.SourceVersion;
33 
34 
35/**
36 * A visitor of program elements based on their {@linkplain
37 * ElementKind kind} with default behavior appropriate for the {@link
38 * SourceVersion#RELEASE_6 RELEASE_6} source version.  For {@linkplain
39 * Element elements} <tt><i>XYZ</i></tt> that may have more than one
40 * kind, the <tt>visit<i>XYZ</i></tt> methods in this class delegate
41 * to the <tt>visit<i>XYZKind</i></tt> method corresponding to the
42 * first argument's kind.  The <tt>visit<i>XYZKind</i></tt> methods
43 * call {@link #defaultAction defaultAction}, passing their arguments
44 * to {@code defaultAction}'s corresponding parameters.
45 *
46 * <p> Methods in this class may be overridden subject to their
47 * general contract.  Note that annotating methods in concrete
48 * subclasses with {@link java.lang.Override @Override} will help
49 * ensure that methods are overridden as intended.
50 *
51 * <p> <b>WARNING:</b> The {@code ElementVisitor} interface
52 * implemented by this class may have methods added to it or the
53 * {@code ElementKind} {@code enum} used in this case may have
54 * constants added to it in the future to accommodate new, currently
55 * unknown, language structures added to future versions of the
56 * Java&trade; programming language.  Therefore, methods whose names
57 * begin with {@code "visit"} may be added to this class in the
58 * future; to avoid incompatibilities, classes which extend this class
59 * should not declare any instance methods with names beginning with
60 * {@code "visit"}.
61 *
62 * <p>When such a new visit method is added, the default
63 * implementation in this class will be to call the {@link
64 * #visitUnknown visitUnknown} method.  A new abstract element kind
65 * visitor class will also be introduced to correspond to the new
66 * language level; this visitor will have different default behavior
67 * for the visit method in question.  When the new visitor is
68 * introduced, all or portions of this visitor may be deprecated.
69 *
70 * @param <R> the return type of this visitor's methods.  Use {@link
71 *            Void} for visitors that do not need to return results.
72 * @param <P> the type of the additional parameter to this visitor's
73 *            methods.  Use {@code Void} for visitors that do not need an
74 *            additional parameter.
75 *
76 * @author Joseph D. Darcy
77 * @author Scott Seligman
78 * @author Peter von der Ah&eacute;
79 * @since 1.6
80 */
81@SupportedSourceVersion(RELEASE_6)
82public class ElementKindVisitor6<R, P>
83                  extends SimpleElementVisitor6<R, P> {
84    /**
85     * Constructor for concrete subclasses; uses {@code null} for the
86     * default value.
87     */
88    protected ElementKindVisitor6() {
89        super(null);
90    }
91 
92    /**
93     * Constructor for concrete subclasses; uses the argument for the
94     * default value.
95     *
96     * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
97     */
98    protected ElementKindVisitor6(R defaultValue) {
99        super(defaultValue);
100    }
101 
102    /**
103     * {@inheritDoc}
104     *
105     * The element argument has kind {@code PACKAGE}.
106     *
107     * @param e {@inheritDoc}
108     * @param p {@inheritDoc}
109     * @return  {@inheritDoc}
110     */
111    @Override
112    public R visitPackage(PackageElement e, P p) {
113        assert e.getKind() == PACKAGE: "Bad kind on PackageElement";
114        return defaultAction(e, p);
115    }
116 
117    /**
118     * Visits a type element, dispatching to the visit method for the
119     * specific {@linkplain ElementKind kind} of type, {@code
120     * ANNOTATION_TYPE}, {@code CLASS}, {@code ENUM}, or {@code
121     * INTERFACE}.
122     *
123     * @param e {@inheritDoc}
124     * @param p {@inheritDoc}
125     * @return  the result of the kind-specific visit method
126     */
127    @Override
128    public R visitType(TypeElement e, P p) {
129        ElementKind k = e.getKind();
130        switch(k) {
131        case ANNOTATION_TYPE:
132            return visitTypeAsAnnotationType(e, p);
133 
134        case CLASS:
135            return visitTypeAsClass(e, p);
136 
137        case ENUM:
138            return visitTypeAsEnum(e, p);
139 
140        case INTERFACE:
141            return visitTypeAsInterface(e, p);
142 
143        default:
144            throw new AssertionError("Bad kind " + k + " for TypeElement" + e);
145        }
146    }
147 
148    /**
149     * Visits an {@code ANNOTATION_TYPE} type element by calling
150     * {@code defaultAction}.
151     *
152     * @param e the element to visit
153     * @param p a visitor-specified parameter
154     * @return  the result of {@code defaultAction}
155     */
156    public R visitTypeAsAnnotationType(TypeElement e, P p) {
157        return defaultAction(e, p);
158    }
159 
160    /**
161     * Visits a {@code CLASS} type element by calling {@code
162     * defaultAction}.
163     *
164     * @param e the element to visit
165     * @param p a visitor-specified parameter
166     * @return  the result of {@code defaultAction}
167     */
168    public R visitTypeAsClass(TypeElement e, P p) {
169        return defaultAction(e, p);
170    }
171 
172    /**
173     * Visits an {@code ENUM} type element by calling {@code
174     * defaultAction}.
175     *
176     * @param e the element to visit
177     * @param p a visitor-specified parameter
178     * @return  the result of {@code defaultAction}
179     */
180    public R visitTypeAsEnum(TypeElement e, P p) {
181        return defaultAction(e, p);
182    }
183 
184    /**
185     * Visits an {@code INTERFACE} type element by calling {@code
186     * defaultAction}.
187     *.
188     * @param e the element to visit
189     * @param p a visitor-specified parameter
190     * @return  the result of {@code defaultAction}
191     */
192    public R visitTypeAsInterface(TypeElement e, P p) {
193        return defaultAction(e, p);
194    }
195 
196    /**
197     * Visits a variable element, dispatching to the visit method for
198     * the specific {@linkplain ElementKind kind} of variable, {@code
199     * ENUM_CONSTANT}, {@code EXCEPTION_PARAMETER}, {@code FIELD},
200     * {@code LOCAL_VARIABLE}, or {@code PARAMETER}.
201     * @param e {@inheritDoc}
202     * @param p {@inheritDoc}
203     * @return  the result of the kind-specific visit method
204     */
205    @Override
206    public R visitVariable(VariableElement e, P p) {
207        ElementKind k = e.getKind();
208        switch(k) {
209        case ENUM_CONSTANT:
210            return visitVariableAsEnumConstant(e, p);
211 
212        case EXCEPTION_PARAMETER:
213            return visitVariableAsExceptionParameter(e, p);
214 
215        case FIELD:
216            return visitVariableAsField(e, p);
217 
218        case LOCAL_VARIABLE:
219            return visitVariableAsLocalVariable(e, p);
220 
221        case PARAMETER:
222            return visitVariableAsParameter(e, p);
223 
224        default:
225            throw new AssertionError("Bad kind " + k + " for VariableElement" + e);
226        }
227 
228    }
229 
230    /**
231     * Visits an {@code ENUM_CONSTANT} variable element by calling
232     * {@code defaultAction}.
233     *
234     * @param e the element to visit
235     * @param p a visitor-specified parameter
236     * @return  the result of {@code defaultAction}
237     */
238    public R visitVariableAsEnumConstant(VariableElement e, P p) {
239        return defaultAction(e, p);
240    }
241 
242    /**
243     * Visits an {@code EXCEPTION_PARAMETER} variable element by calling
244     * {@code defaultAction}.
245     *
246     * @param e the element to visit
247     * @param p a visitor-specified parameter
248     * @return  the result of {@code defaultAction}
249     */
250    public R visitVariableAsExceptionParameter(VariableElement e, P p) {
251        return defaultAction(e, p);
252    }
253 
254    /**
255     * Visits a {@code FIELD} variable element by calling
256     * {@code defaultAction}.
257     *
258     * @param e the element to visit
259     * @param p a visitor-specified parameter
260     * @return  the result of {@code defaultAction}
261     */
262    public R visitVariableAsField(VariableElement e, P p) {
263        return defaultAction(e, p);
264    }
265 
266    /**
267     * Visits a {@code LOCAL_VARIABLE} variable element by calling
268     * {@code defaultAction}.
269     *
270     * @param e the element to visit
271     * @param p a visitor-specified parameter
272     * @return  the result of {@code defaultAction}
273     */
274    public R visitVariableAsLocalVariable(VariableElement e, P p) {
275        return defaultAction(e, p);
276    }
277 
278    /**
279     * Visits a {@code PARAMETER} variable element by calling
280     * {@code defaultAction}.
281     *
282     * @param e the element to visit
283     * @param p a visitor-specified parameter
284     * @return  the result of {@code defaultAction}
285     */
286    public R visitVariableAsParameter(VariableElement e, P p) {
287        return defaultAction(e, p);
288    }
289 
290    /**
291     * Visits an executable element, dispatching to the visit method
292     * for the specific {@linkplain ElementKind kind} of executable,
293     * {@code CONSTRUCTOR}, {@code INSTANCE_INIT}, {@code METHOD}, or
294     * {@code STATIC_INIT}.
295     *
296     * @param e {@inheritDoc}
297     * @param p {@inheritDoc}
298     * @return  the result of the kind-specific visit method
299     */
300    @Override
301    public R visitExecutable(ExecutableElement e, P p) {
302        ElementKind k = e.getKind();
303        switch(k) {
304        case CONSTRUCTOR:
305            return visitExecutableAsConstructor(e, p);
306 
307        case INSTANCE_INIT:
308            return visitExecutableAsInstanceInit(e, p);
309 
310        case METHOD:
311            return visitExecutableAsMethod(e, p);
312 
313        case STATIC_INIT:
314            return visitExecutableAsStaticInit(e, p);
315 
316        default:
317            throw new AssertionError("Bad kind " + k + " for ExecutableElement" + e);
318        }
319    }
320 
321    /**
322     * Visits a {@code CONSTRUCTOR} executable element by calling
323     * {@code defaultAction}.
324     *
325     * @param e the element to visit
326     * @param p a visitor-specified parameter
327     * @return  the result of {@code defaultAction}
328     */
329    public R visitExecutableAsConstructor(ExecutableElement e, P p) {
330        return defaultAction(e, p);
331    }
332 
333    /**
334     * Visits an {@code INSTANCE_INIT} executable element by calling
335     * {@code defaultAction}.
336     *
337     * @param e the element to visit
338     * @param p a visitor-specified parameter
339     * @return  the result of {@code defaultAction}
340     */
341    public R visitExecutableAsInstanceInit(ExecutableElement e, P p) {
342        return defaultAction(e, p);
343    }
344 
345    /**
346     * Visits a {@code METHOD} executable element by calling
347     * {@code defaultAction}.
348     *
349     * @param e the element to visit
350     * @param p a visitor-specified parameter
351     * @return  the result of {@code defaultAction}
352     */
353    public R visitExecutableAsMethod(ExecutableElement e, P p) {
354        return defaultAction(e, p);
355    }
356 
357    /**
358     * Visits a {@code STATIC_INIT} executable element by calling
359     * {@code defaultAction}.
360     *
361     * @param e the element to visit
362     * @param p a visitor-specified parameter
363     * @return  the result of {@code defaultAction}
364     */
365    public R visitExecutableAsStaticInit(ExecutableElement e, P p) {
366        return defaultAction(e, p);
367    }
368 
369 
370    /**
371     * {@inheritDoc}
372     *
373     * The element argument has kind {@code TYPE_PARAMETER}.
374     *
375     * @param e {@inheritDoc}
376     * @param p {@inheritDoc}
377     * @return  {@inheritDoc}
378     */
379    @Override
380    public R visitTypeParameter(TypeParameterElement e, P p) {
381        assert e.getKind() == TYPE_PARAMETER: "Bad kind on TypeParameterElement";
382        return defaultAction(e, p);
383    }
384}

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