KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > corext > refactoring > typeconstraints > ConstraintCollector


1 /*******************************************************************************
2  * Copyright (c) 2000, 2006 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.jdt.internal.corext.refactoring.typeconstraints;
12
13 import java.util.Arrays JavaDoc;
14 import java.util.LinkedHashSet JavaDoc;
15 import java.util.Set JavaDoc;
16
17 import org.eclipse.core.runtime.Assert;
18
19 import org.eclipse.jdt.core.dom.ASTVisitor;
20 import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
21 import org.eclipse.jdt.core.dom.ArrayAccess;
22 import org.eclipse.jdt.core.dom.ArrayCreation;
23 import org.eclipse.jdt.core.dom.ArrayInitializer;
24 import org.eclipse.jdt.core.dom.ArrayType;
25 import org.eclipse.jdt.core.dom.AssertStatement;
26 import org.eclipse.jdt.core.dom.Assignment;
27 import org.eclipse.jdt.core.dom.Block;
28 import org.eclipse.jdt.core.dom.BooleanLiteral;
29 import org.eclipse.jdt.core.dom.BreakStatement;
30 import org.eclipse.jdt.core.dom.CastExpression;
31 import org.eclipse.jdt.core.dom.CatchClause;
32 import org.eclipse.jdt.core.dom.CharacterLiteral;
33 import org.eclipse.jdt.core.dom.ClassInstanceCreation;
34 import org.eclipse.jdt.core.dom.CompilationUnit;
35 import org.eclipse.jdt.core.dom.ConditionalExpression;
36 import org.eclipse.jdt.core.dom.ConstructorInvocation;
37 import org.eclipse.jdt.core.dom.ContinueStatement;
38 import org.eclipse.jdt.core.dom.DoStatement;
39 import org.eclipse.jdt.core.dom.EmptyStatement;
40 import org.eclipse.jdt.core.dom.ExpressionStatement;
41 import org.eclipse.jdt.core.dom.FieldAccess;
42 import org.eclipse.jdt.core.dom.FieldDeclaration;
43 import org.eclipse.jdt.core.dom.ForStatement;
44 import org.eclipse.jdt.core.dom.IfStatement;
45 import org.eclipse.jdt.core.dom.ImportDeclaration;
46 import org.eclipse.jdt.core.dom.InfixExpression;
47 import org.eclipse.jdt.core.dom.Initializer;
48 import org.eclipse.jdt.core.dom.InstanceofExpression;
49 import org.eclipse.jdt.core.dom.Javadoc;
50 import org.eclipse.jdt.core.dom.LabeledStatement;
51 import org.eclipse.jdt.core.dom.MethodDeclaration;
52 import org.eclipse.jdt.core.dom.MethodInvocation;
53 import org.eclipse.jdt.core.dom.NullLiteral;
54 import org.eclipse.jdt.core.dom.NumberLiteral;
55 import org.eclipse.jdt.core.dom.PackageDeclaration;
56 import org.eclipse.jdt.core.dom.ParenthesizedExpression;
57 import org.eclipse.jdt.core.dom.PostfixExpression;
58 import org.eclipse.jdt.core.dom.PrefixExpression;
59 import org.eclipse.jdt.core.dom.PrimitiveType;
60 import org.eclipse.jdt.core.dom.QualifiedName;
61 import org.eclipse.jdt.core.dom.ReturnStatement;
62 import org.eclipse.jdt.core.dom.SimpleName;
63 import org.eclipse.jdt.core.dom.SimpleType;
64 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
65 import org.eclipse.jdt.core.dom.StringLiteral;
66 import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
67 import org.eclipse.jdt.core.dom.SuperFieldAccess;
68 import org.eclipse.jdt.core.dom.SuperMethodInvocation;
69 import org.eclipse.jdt.core.dom.SwitchCase;
70 import org.eclipse.jdt.core.dom.SwitchStatement;
71 import org.eclipse.jdt.core.dom.SynchronizedStatement;
72 import org.eclipse.jdt.core.dom.ThisExpression;
73 import org.eclipse.jdt.core.dom.ThrowStatement;
74 import org.eclipse.jdt.core.dom.TryStatement;
75 import org.eclipse.jdt.core.dom.TypeDeclaration;
76 import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
77 import org.eclipse.jdt.core.dom.TypeLiteral;
78 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
79 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
80 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
81 import org.eclipse.jdt.core.dom.WhileStatement;
82
83
84 public final class ConstraintCollector extends ASTVisitor {
85
86     private final ConstraintCreator fCreator;
87     private final Set JavaDoc fConstraints;
88     
89     public ConstraintCollector() {
90         this(new FullConstraintCreator());
91     }
92     
93     public ConstraintCollector(ConstraintCreator creator) {
94         Assert.isNotNull(creator);
95         fCreator= creator;
96         fConstraints= new LinkedHashSet JavaDoc();
97     }
98
99     private void add(ITypeConstraint[] constraints){
100         fConstraints.addAll(Arrays.asList(constraints));
101     }
102     
103     public void clear(){
104         fConstraints.clear();
105     }
106
107     public ITypeConstraint[] getConstraints(){
108         return (ITypeConstraint[]) fConstraints.toArray(new ITypeConstraint[fConstraints.size()]);
109     }
110     
111     //------------------------- visit methods -------------------------//
112

113     /* (non-Javadoc)
114      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
115      */

116     public boolean visit(AnonymousClassDeclaration node) {
117         add(fCreator.create(node));
118         return true;
119     }
120     
121     /* (non-Javadoc)
122      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
123      */

124     public boolean visit(ArrayAccess node) {
125         add(fCreator.create(node));
126         return true;
127     }
128     
129     /* (non-Javadoc)
130      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
131      */

132     public boolean visit(ArrayCreation node) {
133         add(fCreator.create(node));
134         return true;
135     }
136     
137     /* (non-Javadoc)
138      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
139      */

140     public boolean visit(ArrayInitializer node) {
141         add(fCreator.create(node));
142         return true;
143     }
144     
145     /* (non-Javadoc)
146      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
147      */

148     public boolean visit(ArrayType node) {
149         add(fCreator.create(node));
150         return true;
151     }
152     
153     /* (non-Javadoc)
154      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AssertStatement)
155      */

156     public boolean visit(AssertStatement node) {
157         add(fCreator.create(node));
158         return true;
159     }
160     
161     /* (non-Javadoc)
162      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
163      */

164     public boolean visit(Assignment node) {
165         add(fCreator.create(node));
166         return true;
167     }
168     
169     /* (non-Javadoc)
170      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
171      */

172     public boolean visit(Block node) {
173         add(fCreator.create(node));
174         return true;
175     }
176     
177     /* (non-Javadoc)
178      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
179      */

180     public boolean visit(BooleanLiteral node) {
181         add(fCreator.create(node));
182         return true;
183     }
184     
185     /* (non-Javadoc)
186      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
187      */

188     public boolean visit(BreakStatement node) {
189         add(fCreator.create(node));
190         return true;
191     }
192     
193     /* (non-Javadoc)
194      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
195      */

196     public boolean visit(CastExpression node) {
197         add(fCreator.create(node));
198         return true;
199     }
200     
201     /* (non-Javadoc)
202      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
203      */

204     public boolean visit(CatchClause node) {
205         add(fCreator.create(node));
206         return true;
207     }
208     
209     /* (non-Javadoc)
210      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
211      */

212     public boolean visit(CharacterLiteral node) {
213         add(fCreator.create(node));
214         return true;
215     }
216     
217     /* (non-Javadoc)
218      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
219      */

220     public boolean visit(ClassInstanceCreation node) {
221         add(fCreator.create(node));
222         return true;
223     }
224     
225     /* (non-Javadoc)
226      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
227      */

228     public boolean visit(CompilationUnit node) {
229         add(fCreator.create(node));
230         return true;
231     }
232     
233     /* (non-Javadoc)
234      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
235      */

236     public boolean visit(ConditionalExpression node) {
237         add(fCreator.create(node));
238         return true;
239     }
240     
241     /* (non-Javadoc)
242      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
243      */

244     public boolean visit(ConstructorInvocation node) {
245         add(fCreator.create(node));
246         return true;
247     }
248     
249     /* (non-Javadoc)
250      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
251      */

252     public boolean visit(ContinueStatement node) {
253         add(fCreator.create(node));
254         return true;
255     }
256     
257     /* (non-Javadoc)
258      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
259      */

260     public boolean visit(DoStatement node) {
261         add(fCreator.create(node));
262         return true;
263     }
264     
265     /* (non-Javadoc)
266      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
267      */

268     public boolean visit(EmptyStatement node) {
269         add(fCreator.create(node));
270         return true;
271     }
272     
273     /* (non-Javadoc)
274      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
275      */

276     public boolean visit(ExpressionStatement node) {
277         add(fCreator.create(node));
278         return true;
279     }
280     
281     /* (non-Javadoc)
282      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
283      */

284     public boolean visit(FieldAccess node) {
285         add(fCreator.create(node));
286         return true;
287     }
288     
289     /* (non-Javadoc)
290      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
291      */

292     public boolean visit(FieldDeclaration node) {
293         add(fCreator.create(node));
294         return true;
295     }
296     
297     /* (non-Javadoc)
298      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
299      */

300     public boolean visit(ForStatement node) {
301         add(fCreator.create(node));
302         return true;
303     }
304     
305     /* (non-Javadoc)
306      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
307      */

308     public boolean visit(IfStatement node) {
309         add(fCreator.create(node));
310         return true;
311     }
312     
313     /* (non-Javadoc)
314      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
315      */

316     public boolean visit(ImportDeclaration node) {
317         add(fCreator.create(node));
318         return true;
319     }
320     
321     /* (non-Javadoc)
322      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
323      */

324     public boolean visit(InfixExpression node) {
325         add(fCreator.create(node));
326         return true;
327     }
328     
329     /* (non-Javadoc)
330      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
331      */

332     public boolean visit(Initializer node) {
333         add(fCreator.create(node));
334         return true;
335     }
336     
337     /* (non-Javadoc)
338      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
339      */

340     public boolean visit(InstanceofExpression node) {
341         add(fCreator.create(node));
342         return true;
343     }
344     
345     /* (non-Javadoc)
346      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
347      */

348     public boolean visit(Javadoc node) {
349         add(fCreator.create(node));
350         return true;
351     }
352     
353     /* (non-Javadoc)
354      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
355      */

356     public boolean visit(LabeledStatement node) {
357         add(fCreator.create(node));
358         return true;
359     }
360     
361     /* (non-Javadoc)
362      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
363      */

364     public boolean visit(MethodDeclaration node) {
365         add(fCreator.create(node));
366         return true;
367     }
368     
369     /* (non-Javadoc)
370      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
371      */

372     public boolean visit(MethodInvocation node) {
373         add(fCreator.create(node));
374         return true;
375     }
376     
377     /* (non-Javadoc)
378      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
379      */

380     public boolean visit(NullLiteral node) {
381         add(fCreator.create(node));
382         return true;
383     }
384     
385     /* (non-Javadoc)
386      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
387      */

388     public boolean visit(NumberLiteral node) {
389         add(fCreator.create(node));
390         return true;
391     }
392     
393     /* (non-Javadoc)
394      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
395      */

396     public boolean visit(PackageDeclaration node) {
397         add(fCreator.create(node));
398         return true;
399     }
400     
401     /* (non-Javadoc)
402      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
403      */

404     public boolean visit(ParenthesizedExpression node) {
405         add(fCreator.create(node));
406         return true;
407     }
408     
409     /* (non-Javadoc)
410      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
411      */

412     public boolean visit(PostfixExpression node) {
413         add(fCreator.create(node));
414         return true;
415     }
416     
417     /* (non-Javadoc)
418      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
419      */

420     public boolean visit(PrefixExpression node) {
421         add(fCreator.create(node));
422         return true;
423     }
424     
425     /* (non-Javadoc)
426      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
427      */

428     public boolean visit(PrimitiveType node) {
429         add(fCreator.create(node));
430         return true;
431     }
432     
433     /* (non-Javadoc)
434      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
435      */

436     public boolean visit(QualifiedName node) {
437         add(fCreator.create(node));
438         return true;
439     }
440     
441     /* (non-Javadoc)
442      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
443      */

444     public boolean visit(ReturnStatement node) {
445         add(fCreator.create(node));
446         return true;
447     }
448     
449     /* (non-Javadoc)
450      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
451      */

452     public boolean visit(SimpleName node) {
453         add(fCreator.create(node));
454         return true;
455     }
456     
457     /* (non-Javadoc)
458      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
459      */

460     public boolean visit(SimpleType node) {
461         add(fCreator.create(node));
462         return true;
463     }
464     
465     /* (non-Javadoc)
466      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
467      */

468     public boolean visit(SingleVariableDeclaration node) {
469         add(fCreator.create(node));
470         return true;
471     }
472     
473     /* (non-Javadoc)
474      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
475      */

476     public boolean visit(StringLiteral node) {
477         add(fCreator.create(node));
478         return true;
479     }
480     
481     /* (non-Javadoc)
482      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
483      */

484     public boolean visit(SuperConstructorInvocation node) {
485         add(fCreator.create(node));
486         return true;
487     }
488     
489     /* (non-Javadoc)
490      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
491      */

492     public boolean visit(SuperFieldAccess node) {
493         add(fCreator.create(node));
494         return true;
495     }
496     
497     /* (non-Javadoc)
498      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
499      */

500     public boolean visit(SuperMethodInvocation node) {
501         add(fCreator.create(node));
502         return true;
503     }
504     
505     /* (non-Javadoc)
506      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
507      */

508     public boolean visit(SwitchCase node) {
509         add(fCreator.create(node));
510         return true;
511     }
512     
513     /* (non-Javadoc)
514      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchStatement)
515      */

516     public boolean visit(SwitchStatement node) {
517         add(fCreator.create(node));
518         return true;
519     }
520     
521     /* (non-Javadoc)
522      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
523      */

524     public boolean visit(SynchronizedStatement node) {
525         add(fCreator.create(node));
526         return true;
527     }
528     
529     /* (non-Javadoc)
530      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
531      */

532     public boolean visit(ThisExpression node) {
533         add(fCreator.create(node));
534         return true;
535     }
536     
537     /* (non-Javadoc)
538      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
539      */

540     public boolean visit(ThrowStatement node) {
541         add(fCreator.create(node));
542         return true;
543     }
544     
545     /* (non-Javadoc)
546      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
547      */

548     public boolean visit(TryStatement node) {
549         add(fCreator.create(node));
550         return true;
551     }
552     
553     /* (non-Javadoc)
554      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
555      */

556     public boolean visit(TypeDeclaration node) {
557         add(fCreator.create(node));
558         return true;
559         
560         // TODO account for enums and annotations
561
}
562     
563     /* (non-Javadoc)
564      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
565      */

566     public boolean visit(TypeDeclarationStatement node) {
567         add(fCreator.create(node));
568         return true;
569     }
570     
571     /* (non-Javadoc)
572      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
573      */

574     public boolean visit(TypeLiteral node) {
575         add(fCreator.create(node));
576         return true;
577     }
578     
579     /* (non-Javadoc)
580      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
581      */

582     public boolean visit(VariableDeclarationExpression node) {
583         add(fCreator.create(node));
584         return true;
585     }
586     
587     /* (non-Javadoc)
588      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
589      */

590     public boolean visit(VariableDeclarationFragment node) {
591         add(fCreator.create(node));
592         return true;
593     }
594     
595     /* (non-Javadoc)
596      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
597      */

598     public boolean visit(VariableDeclarationStatement node) {
599         add(fCreator.create(node));
600         return true;
601     }
602     
603     /* (non-Javadoc)
604      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
605      */

606     public boolean visit(WhileStatement node) {
607         add(fCreator.create(node));
608         return true;
609     }
610 }
611
Popular Tags