KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > core > dom > rewrite > GenericVisitor


1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package org.eclipse.jdt.internal.core.dom.rewrite;
12
13 import org.eclipse.jdt.core.dom.*;
14
15 public class GenericVisitor extends ASTVisitor {
16     
17     //---- Hooks for subclasses -------------------------------------------------
18
19     protected boolean visitNode(ASTNode node) {
20         return true;
21     }
22     
23     protected void endVisitNode(ASTNode node) {
24         // do nothing
25 }
26
27     public boolean visit(AnonymousClassDeclaration node) {
28         return visitNode(node);
29     }
30     public boolean visit(ArrayAccess node) {
31         return visitNode(node);
32     }
33     public boolean visit(ArrayCreation node) {
34         return visitNode(node);
35     }
36     public boolean visit(ArrayInitializer node) {
37         return visitNode(node);
38     }
39     public boolean visit(ArrayType node) {
40         return visitNode(node);
41     }
42     public boolean visit(AssertStatement node) {
43         return visitNode(node);
44     }
45     public boolean visit(Assignment node) {
46         return visitNode(node);
47     }
48     public boolean visit(Block node) {
49         return visitNode(node);
50     }
51     public boolean visit(BooleanLiteral node) {
52         return visitNode(node);
53     }
54     public boolean visit(BreakStatement node) {
55         return visitNode(node);
56     }
57     public boolean visit(CastExpression node) {
58         return visitNode(node);
59     }
60     public boolean visit(CatchClause node) {
61         return visitNode(node);
62     }
63     public boolean visit(CharacterLiteral node) {
64         return visitNode(node);
65     }
66     public boolean visit(ClassInstanceCreation node) {
67         return visitNode(node);
68     }
69     public boolean visit(CompilationUnit node) {
70         return visitNode(node);
71     }
72     public boolean visit(ConditionalExpression node) {
73         return visitNode(node);
74     }
75     public boolean visit(ConstructorInvocation node) {
76         return visitNode(node);
77     }
78     public boolean visit(ContinueStatement node) {
79         return visitNode(node);
80     }
81     public boolean visit(DoStatement node) {
82         return visitNode(node);
83     }
84     public boolean visit(EmptyStatement node) {
85         return visitNode(node);
86     }
87     public boolean visit(ExpressionStatement node) {
88         return visitNode(node);
89     }
90     public boolean visit(FieldAccess node) {
91         return visitNode(node);
92     }
93     public boolean visit(FieldDeclaration node) {
94         return visitNode(node);
95     }
96     public boolean visit(ForStatement node) {
97         return visitNode(node);
98     }
99     public boolean visit(IfStatement node) {
100         return visitNode(node);
101     }
102     public boolean visit(ImportDeclaration node) {
103         return visitNode(node);
104     }
105     public boolean visit(InfixExpression node) {
106         return visitNode(node);
107     }
108     public boolean visit(InstanceofExpression node) {
109         return visitNode(node);
110     }
111     public boolean visit(Initializer node) {
112         return visitNode(node);
113     }
114     public boolean visit(Javadoc node) {
115         return visitNode(node);
116     }
117     public boolean visit(LabeledStatement node) {
118         return visitNode(node);
119     }
120     public boolean visit(MethodDeclaration node) {
121         return visitNode(node);
122     }
123     public boolean visit(MethodInvocation node) {
124         return visitNode(node);
125     }
126     public boolean visit(NullLiteral node) {
127         return visitNode(node);
128     }
129     public boolean visit(NumberLiteral node) {
130         return visitNode(node);
131     }
132     public boolean visit(PackageDeclaration node) {
133         return visitNode(node);
134     }
135     public boolean visit(ParenthesizedExpression node) {
136         return visitNode(node);
137     }
138     public boolean visit(PostfixExpression node) {
139         return visitNode(node);
140     }
141     public boolean visit(PrefixExpression node) {
142         return visitNode(node);
143     }
144     public boolean visit(PrimitiveType node) {
145         return visitNode(node);
146     }
147     public boolean visit(QualifiedName node) {
148         return visitNode(node);
149     }
150     public boolean visit(ReturnStatement node) {
151         return visitNode(node);
152     }
153     public boolean visit(SimpleName node) {
154         return visitNode(node);
155     }
156     public boolean visit(SimpleType node) {
157         return visitNode(node);
158     }
159     public boolean visit(StringLiteral node) {
160         return visitNode(node);
161     }
162     public boolean visit(SuperConstructorInvocation node) {
163         return visitNode(node);
164     }
165     public boolean visit(SuperFieldAccess node) {
166         return visitNode(node);
167     }
168     public boolean visit(SuperMethodInvocation node) {
169         return visitNode(node);
170     }
171     public boolean visit(SwitchCase node) {
172         return visitNode(node);
173     }
174     public boolean visit(SwitchStatement node) {
175         return visitNode(node);
176     }
177     public boolean visit(SynchronizedStatement node) {
178         return visitNode(node);
179     }
180     public boolean visit(ThisExpression node) {
181         return visitNode(node);
182     }
183     public boolean visit(ThrowStatement node) {
184         return visitNode(node);
185     }
186     public boolean visit(TryStatement node) {
187         return visitNode(node);
188     }
189     public boolean visit(TypeDeclaration node) {
190         return visitNode(node);
191     }
192     public boolean visit(TypeDeclarationStatement node) {
193         return visitNode(node);
194     }
195     public boolean visit(TypeLiteral node) {
196         return visitNode(node);
197     }
198     public boolean visit(SingleVariableDeclaration node) {
199         return visitNode(node);
200     }
201     public boolean visit(VariableDeclarationExpression node) {
202         return visitNode(node);
203     }
204     public boolean visit(VariableDeclarationStatement node) {
205         return visitNode(node);
206     }
207     public boolean visit(VariableDeclarationFragment node) {
208         return visitNode(node);
209     }
210     public boolean visit(WhileStatement node) {
211         return visitNode(node);
212     }
213
214     public void endVisit(AnonymousClassDeclaration node) {
215         endVisitNode(node);
216     }
217     public void endVisit(ArrayAccess node) {
218         endVisitNode(node);
219     }
220     public void endVisit(ArrayCreation node) {
221         endVisitNode(node);
222     }
223     public void endVisit(ArrayInitializer node) {
224         endVisitNode(node);
225     }
226     public void endVisit(ArrayType node) {
227         endVisitNode(node);
228     }
229     public void endVisit(AssertStatement node) {
230         endVisitNode(node);
231     }
232     public void endVisit(Assignment node) {
233         endVisitNode(node);
234     }
235     public void endVisit(Block node) {
236         endVisitNode(node);
237     }
238     public void endVisit(BooleanLiteral node) {
239         endVisitNode(node);
240     }
241     public void endVisit(BreakStatement node) {
242         endVisitNode(node);
243     }
244     public void endVisit(CastExpression node) {
245         endVisitNode(node);
246     }
247     public void endVisit(CatchClause node) {
248         endVisitNode(node);
249     }
250     public void endVisit(CharacterLiteral node) {
251         endVisitNode(node);
252     }
253     public void endVisit(ClassInstanceCreation node) {
254         endVisitNode(node);
255     }
256     public void endVisit(CompilationUnit node) {
257         endVisitNode(node);
258     }
259     public void endVisit(ConditionalExpression node) {
260         endVisitNode(node);
261     }
262     public void endVisit(ConstructorInvocation node) {
263         endVisitNode(node);
264     }
265     public void endVisit(ContinueStatement node) {
266         endVisitNode(node);
267     }
268     public void endVisit(DoStatement node) {
269         endVisitNode(node);
270     }
271     public void endVisit(EmptyStatement node) {
272         endVisitNode(node);
273     }
274     public void endVisit(ExpressionStatement node) {
275         endVisitNode(node);
276     }
277     public void endVisit(FieldAccess node) {
278         endVisitNode(node);
279     }
280     public void endVisit(FieldDeclaration node) {
281         endVisitNode(node);
282     }
283     public void endVisit(ForStatement node) {
284         endVisitNode(node);
285     }
286     public void endVisit(IfStatement node) {
287         endVisitNode(node);
288     }
289     public void endVisit(ImportDeclaration node) {
290         endVisitNode(node);
291     }
292     public void endVisit(InfixExpression node) {
293         endVisitNode(node);
294     }
295     public void endVisit(InstanceofExpression node) {
296         endVisitNode(node);
297     }
298     public void endVisit(Initializer node) {
299         endVisitNode(node);
300     }
301     public void endVisit(Javadoc node) {
302         endVisitNode(node);
303     }
304     public void endVisit(LabeledStatement node) {
305         endVisitNode(node);
306     }
307     public void endVisit(MethodDeclaration node) {
308         endVisitNode(node);
309     }
310     public void endVisit(MethodInvocation node) {
311         endVisitNode(node);
312     }
313     public void endVisit(NullLiteral node) {
314         endVisitNode(node);
315     }
316     public void endVisit(NumberLiteral node) {
317         endVisitNode(node);
318     }
319     public void endVisit(PackageDeclaration node) {
320         endVisitNode(node);
321     }
322     public void endVisit(ParenthesizedExpression node) {
323         endVisitNode(node);
324     }
325     public void endVisit(PostfixExpression node) {
326         endVisitNode(node);
327     }
328     public void endVisit(PrefixExpression node) {
329         endVisitNode(node);
330     }
331     public void endVisit(PrimitiveType node) {
332         endVisitNode(node);
333     }
334     public void endVisit(QualifiedName node) {
335         endVisitNode(node);
336     }
337     public void endVisit(ReturnStatement node) {
338         endVisitNode(node);
339     }
340     public void endVisit(SimpleName node) {
341         endVisitNode(node);
342     }
343     public void endVisit(SimpleType node) {
344         endVisitNode(node);
345     }
346     public void endVisit(StringLiteral node) {
347         endVisitNode(node);
348     }
349     public void endVisit(SuperConstructorInvocation node) {
350         endVisitNode(node);
351     }
352     public void endVisit(SuperFieldAccess node) {
353         endVisitNode(node);
354     }
355     public void endVisit(SuperMethodInvocation node) {
356         endVisitNode(node);
357     }
358     public void endVisit(SwitchCase node) {
359         endVisitNode(node);
360     }
361     public void endVisit(SwitchStatement node) {
362         endVisitNode(node);
363     }
364     public void endVisit(SynchronizedStatement node) {
365         endVisitNode(node);
366     }
367     public void endVisit(ThisExpression node) {
368         endVisitNode(node);
369     }
370     public void endVisit(ThrowStatement node) {
371         endVisitNode(node);
372     }
373     public void endVisit(TryStatement node) {
374         endVisitNode(node);
375     }
376     public void endVisit(TypeDeclaration node) {
377         endVisitNode(node);
378     }
379     public void endVisit(TypeDeclarationStatement node) {
380         endVisitNode(node);
381     }
382     public void endVisit(TypeLiteral node) {
383         endVisitNode(node);
384     }
385     public void endVisit(SingleVariableDeclaration node) {
386         endVisitNode(node);
387     }
388     public void endVisit(VariableDeclarationExpression node) {
389         endVisitNode(node);
390     }
391     public void endVisit(VariableDeclarationStatement node) {
392         endVisitNode(node);
393     }
394     public void endVisit(VariableDeclarationFragment node) {
395         endVisitNode(node);
396     }
397     public void endVisit(WhileStatement node) {
398         endVisitNode(node);
399     }
400 }
401
Popular Tags