KickJava   Java API By Example, From Geeks To Geeks.

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


1 /*******************************************************************************
2  * Copyright (c) 2000, 2005 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 org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
14 import org.eclipse.jdt.core.dom.ArrayAccess;
15 import org.eclipse.jdt.core.dom.ArrayCreation;
16 import org.eclipse.jdt.core.dom.ArrayInitializer;
17 import org.eclipse.jdt.core.dom.ArrayType;
18 import org.eclipse.jdt.core.dom.AssertStatement;
19 import org.eclipse.jdt.core.dom.Assignment;
20 import org.eclipse.jdt.core.dom.Block;
21 import org.eclipse.jdt.core.dom.BooleanLiteral;
22 import org.eclipse.jdt.core.dom.BreakStatement;
23 import org.eclipse.jdt.core.dom.CastExpression;
24 import org.eclipse.jdt.core.dom.CatchClause;
25 import org.eclipse.jdt.core.dom.CharacterLiteral;
26 import org.eclipse.jdt.core.dom.ClassInstanceCreation;
27 import org.eclipse.jdt.core.dom.CompilationUnit;
28 import org.eclipse.jdt.core.dom.ConditionalExpression;
29 import org.eclipse.jdt.core.dom.ConstructorInvocation;
30 import org.eclipse.jdt.core.dom.ContinueStatement;
31 import org.eclipse.jdt.core.dom.DoStatement;
32 import org.eclipse.jdt.core.dom.EmptyStatement;
33 import org.eclipse.jdt.core.dom.ExpressionStatement;
34 import org.eclipse.jdt.core.dom.FieldAccess;
35 import org.eclipse.jdt.core.dom.FieldDeclaration;
36 import org.eclipse.jdt.core.dom.ForStatement;
37 import org.eclipse.jdt.core.dom.IfStatement;
38 import org.eclipse.jdt.core.dom.ImportDeclaration;
39 import org.eclipse.jdt.core.dom.InfixExpression;
40 import org.eclipse.jdt.core.dom.Initializer;
41 import org.eclipse.jdt.core.dom.InstanceofExpression;
42 import org.eclipse.jdt.core.dom.Javadoc;
43 import org.eclipse.jdt.core.dom.LabeledStatement;
44 import org.eclipse.jdt.core.dom.MethodDeclaration;
45 import org.eclipse.jdt.core.dom.MethodInvocation;
46 import org.eclipse.jdt.core.dom.NullLiteral;
47 import org.eclipse.jdt.core.dom.NumberLiteral;
48 import org.eclipse.jdt.core.dom.PackageDeclaration;
49 import org.eclipse.jdt.core.dom.ParenthesizedExpression;
50 import org.eclipse.jdt.core.dom.PostfixExpression;
51 import org.eclipse.jdt.core.dom.PrefixExpression;
52 import org.eclipse.jdt.core.dom.PrimitiveType;
53 import org.eclipse.jdt.core.dom.QualifiedName;
54 import org.eclipse.jdt.core.dom.ReturnStatement;
55 import org.eclipse.jdt.core.dom.SimpleName;
56 import org.eclipse.jdt.core.dom.SimpleType;
57 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
58 import org.eclipse.jdt.core.dom.StringLiteral;
59 import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
60 import org.eclipse.jdt.core.dom.SuperFieldAccess;
61 import org.eclipse.jdt.core.dom.SuperMethodInvocation;
62 import org.eclipse.jdt.core.dom.SwitchCase;
63 import org.eclipse.jdt.core.dom.SwitchStatement;
64 import org.eclipse.jdt.core.dom.SynchronizedStatement;
65 import org.eclipse.jdt.core.dom.ThisExpression;
66 import org.eclipse.jdt.core.dom.ThrowStatement;
67 import org.eclipse.jdt.core.dom.TryStatement;
68 import org.eclipse.jdt.core.dom.TypeDeclaration;
69 import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
70 import org.eclipse.jdt.core.dom.TypeLiteral;
71 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
72 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
73 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
74 import org.eclipse.jdt.core.dom.WhileStatement;
75
76 /**
77  * Empty implementation of a creator - provided to allow subclasses to override only a subset of methods.
78  * Subclass to provide constraint creation functionality.
79  */
80 public class ConstraintCreator {
81
82     public static final ITypeConstraint[] EMPTY_ARRAY= new ITypeConstraint[0];
83     
84     /* (non-Javadoc)
85      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
86      */
87     public ITypeConstraint[] create(AnonymousClassDeclaration node) {
88         return EMPTY_ARRAY;
89     }
90
91     /* (non-Javadoc)
92      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
93      */
94     public ITypeConstraint[] create(ArrayAccess node) {
95         return EMPTY_ARRAY;
96     }
97
98     /* (non-Javadoc)
99      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
100      */
101     public ITypeConstraint[] create(ArrayCreation node) {
102         return EMPTY_ARRAY;
103     }
104
105     /* (non-Javadoc)
106      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
107      */
108     public ITypeConstraint[] create(ArrayInitializer node) {
109         return EMPTY_ARRAY;
110     }
111
112     /* (non-Javadoc)
113      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
114      */
115     public ITypeConstraint[] create(ArrayType node) {
116         return EMPTY_ARRAY;
117     }
118
119     /* (non-Javadoc)
120      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AssertStatement)
121      */
122     public ITypeConstraint[] create(AssertStatement node) {
123         return EMPTY_ARRAY;
124     }
125
126     /* (non-Javadoc)
127      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
128      */
129     public ITypeConstraint[] create(Assignment node) {
130         return EMPTY_ARRAY;
131     }
132
133     /* (non-Javadoc)
134      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
135      */
136     public ITypeConstraint[] create(Block node) {
137         return EMPTY_ARRAY;
138     }
139
140     /* (non-Javadoc)
141      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
142      */
143     public ITypeConstraint[] create(BooleanLiteral node) {
144         return EMPTY_ARRAY;
145     }
146
147     /* (non-Javadoc)
148      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
149      */
150     public ITypeConstraint[] create(BreakStatement node) {
151         return EMPTY_ARRAY;
152     }
153
154     /* (non-Javadoc)
155      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
156      */
157     public ITypeConstraint[] create(CastExpression node) {
158         return EMPTY_ARRAY;
159     }
160
161     /* (non-Javadoc)
162      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
163      */
164     public ITypeConstraint[] create(CatchClause node) {
165         return EMPTY_ARRAY;
166     }
167
168     /* (non-Javadoc)
169      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
170      */
171     public ITypeConstraint[] create(CharacterLiteral node) {
172         return EMPTY_ARRAY;
173     }
174
175     /* (non-Javadoc)
176      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
177      */
178     public ITypeConstraint[] create(ClassInstanceCreation node) {
179         return EMPTY_ARRAY;
180     }
181
182     /* (non-Javadoc)
183      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
184      */
185     public ITypeConstraint[] create(CompilationUnit node) {
186         return EMPTY_ARRAY;
187     }
188
189     /* (non-Javadoc)
190      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
191      */
192     public ITypeConstraint[] create(ConditionalExpression node) {
193         return EMPTY_ARRAY;
194     }
195
196     /* (non-Javadoc)
197      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
198      */
199     public ITypeConstraint[] create(ConstructorInvocation node) {
200         return EMPTY_ARRAY;
201     }
202
203     /* (non-Javadoc)
204      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
205      */
206     public ITypeConstraint[] create(ContinueStatement node) {
207         return EMPTY_ARRAY;
208     }
209
210     /* (non-Javadoc)
211      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
212      */
213     public ITypeConstraint[] create(DoStatement node) {
214         return EMPTY_ARRAY;
215     }
216
217     /* (non-Javadoc)
218      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
219      */
220     public ITypeConstraint[] create(EmptyStatement node) {
221         return EMPTY_ARRAY;
222     }
223
224     /* (non-Javadoc)
225      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
226      */
227     public ITypeConstraint[] create(ExpressionStatement node) {
228         return EMPTY_ARRAY;
229     }
230
231     /* (non-Javadoc)
232      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
233      */
234     public ITypeConstraint[] create(FieldAccess node) {
235         return EMPTY_ARRAY;
236     }
237
238     /* (non-Javadoc)
239      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
240      */
241     public ITypeConstraint[] create(FieldDeclaration node) {
242         return EMPTY_ARRAY;
243     }
244
245     /* (non-Javadoc)
246      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
247      */
248     public ITypeConstraint[] create(ForStatement node) {
249         return EMPTY_ARRAY;
250     }
251
252     /* (non-Javadoc)
253      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
254      */
255     public ITypeConstraint[] create(IfStatement node) {
256         return EMPTY_ARRAY;
257     }
258
259     /* (non-Javadoc)
260      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
261      */
262     public ITypeConstraint[] create(ImportDeclaration node) {
263         return EMPTY_ARRAY;
264     }
265
266     /* (non-Javadoc)
267      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
268      */
269     public ITypeConstraint[] create(InfixExpression node) {
270         return EMPTY_ARRAY;
271     }
272
273     /* (non-Javadoc)
274      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
275      */
276     public ITypeConstraint[] create(Initializer node) {
277         return EMPTY_ARRAY;
278     }
279
280     /* (non-Javadoc)
281      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
282      */
283     public ITypeConstraint[] create(InstanceofExpression node) {
284         return EMPTY_ARRAY;
285     }
286
287     /* (non-Javadoc)
288      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
289      */
290     public ITypeConstraint[] create(Javadoc node) {
291         return EMPTY_ARRAY;
292     }
293
294     /* (non-Javadoc)
295      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
296      */
297     public ITypeConstraint[] create(LabeledStatement node) {
298         return EMPTY_ARRAY;
299     }
300
301     /* (non-Javadoc)
302      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
303      */
304     public ITypeConstraint[] create(MethodDeclaration node) {
305         return EMPTY_ARRAY;
306     }
307
308     /* (non-Javadoc)
309      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
310      */
311     public ITypeConstraint[] create(MethodInvocation node) {
312         return EMPTY_ARRAY;
313     }
314
315     /* (non-Javadoc)
316      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
317      */
318     public ITypeConstraint[] create(NullLiteral node) {
319         return EMPTY_ARRAY;
320     }
321
322     /* (non-Javadoc)
323      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
324      */
325     public ITypeConstraint[] create(NumberLiteral node) {
326         return EMPTY_ARRAY;
327     }
328
329     /* (non-Javadoc)
330      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
331      */
332     public ITypeConstraint[] create(PackageDeclaration node) {
333         return EMPTY_ARRAY;
334     }
335
336     /* (non-Javadoc)
337      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
338      */
339     public ITypeConstraint[] create(ParenthesizedExpression node) {
340         return EMPTY_ARRAY;
341     }
342
343     /* (non-Javadoc)
344      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
345      */
346     public ITypeConstraint[] create(PostfixExpression node) {
347         return EMPTY_ARRAY;
348     }
349
350     /* (non-Javadoc)
351      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
352      */
353     public ITypeConstraint[] create(PrefixExpression node) {
354         return EMPTY_ARRAY;
355     }
356
357     /* (non-Javadoc)
358      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
359      */
360     public ITypeConstraint[] create(PrimitiveType node) {
361         return EMPTY_ARRAY;
362     }
363
364     /* (non-Javadoc)
365      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
366      */
367     public ITypeConstraint[] create(QualifiedName node) {
368         return EMPTY_ARRAY;
369     }
370
371     /* (non-Javadoc)
372      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
373      */
374     public ITypeConstraint[] create(ReturnStatement node) {
375         return EMPTY_ARRAY;
376     }
377
378     /* (non-Javadoc)
379      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
380      */
381     public ITypeConstraint[] create(SimpleName node) {
382         return EMPTY_ARRAY;
383     }
384
385     /* (non-Javadoc)
386      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
387      */
388     public ITypeConstraint[] create(SimpleType node) {
389         return EMPTY_ARRAY;
390     }
391
392     /* (non-Javadoc)
393      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
394      */
395     public ITypeConstraint[] create(SingleVariableDeclaration node) {
396         return EMPTY_ARRAY;
397     }
398
399     /* (non-Javadoc)
400      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
401      */
402     public ITypeConstraint[] create(StringLiteral node) {
403         return EMPTY_ARRAY;
404     }
405
406     /* (non-Javadoc)
407      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
408      */
409     public ITypeConstraint[] create(SuperConstructorInvocation node) {
410         return EMPTY_ARRAY;
411     }
412
413     /* (non-Javadoc)
414      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
415      */
416     public ITypeConstraint[] create(SuperFieldAccess node) {
417         return EMPTY_ARRAY;
418     }
419
420     /* (non-Javadoc)
421      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
422      */
423     public ITypeConstraint[] create(SuperMethodInvocation node) {
424         return EMPTY_ARRAY;
425     }
426
427     /* (non-Javadoc)
428      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
429      */
430     public ITypeConstraint[] create(SwitchCase node) {
431         return EMPTY_ARRAY;
432     }
433
434     /* (non-Javadoc)
435      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchStatement)
436      */
437     public ITypeConstraint[] create(SwitchStatement node) {
438         return EMPTY_ARRAY;
439     }
440
441     /* (non-Javadoc)
442      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
443      */
444     public ITypeConstraint[] create(SynchronizedStatement node) {
445         return EMPTY_ARRAY;
446     }
447
448     /* (non-Javadoc)
449      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
450      */
451     public ITypeConstraint[] create(ThisExpression node) {
452         return EMPTY_ARRAY;
453     }
454
455     /* (non-Javadoc)
456      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
457      */
458     public ITypeConstraint[] create(ThrowStatement node) {
459         return EMPTY_ARRAY;
460     }
461
462     /* (non-Javadoc)
463      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
464      */
465     public ITypeConstraint[] create(TryStatement node) {
466         return EMPTY_ARRAY;
467     }
468
469     /* (non-Javadoc)
470      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
471      */
472     public ITypeConstraint[] create(TypeDeclaration node) {
473         return EMPTY_ARRAY;
474         
475         // TODO account for enums and annotations
476 }
477
478     /* (non-Javadoc)
479      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
480      */
481     public ITypeConstraint[] create(TypeDeclarationStatement node) {
482         return EMPTY_ARRAY;
483     }
484
485     /* (non-Javadoc)
486      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
487      */
488     public ITypeConstraint[] create(TypeLiteral node) {
489         return EMPTY_ARRAY;
490     }
491
492     /* (non-Javadoc)
493      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
494      */
495     public ITypeConstraint[] create(VariableDeclarationExpression node) {
496         return EMPTY_ARRAY;
497     }
498
499     /* (non-Javadoc)
500      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
501      */
502     public ITypeConstraint[] create(VariableDeclarationFragment node) {
503         return EMPTY_ARRAY;
504     }
505
506     /* (non-Javadoc)
507      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
508      */
509     public ITypeConstraint[] create(VariableDeclarationStatement node) {
510         return EMPTY_ARRAY;
511     }
512
513     /* (non-Javadoc)
514      * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
515      */
516     public ITypeConstraint[] create(WhileStatement node) {
517         return EMPTY_ARRAY;
518     }
519
520 }
521
Popular Tags