001 /*
002 * JBoss DNA (http://www.jboss.org/dna)
003 * See the COPYRIGHT.txt file distributed with this work for information
004 * regarding copyright ownership. Some portions may be licensed
005 * to Red Hat, Inc. under one or more contributor license agreements.
006 * See the AUTHORS.txt file in the distribution for a full listing of
007 * individual contributors.
008 *
009 * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
010 * is licensed to you under the terms of the GNU Lesser General Public License as
011 * published by the Free Software Foundation; either version 2.1 of
012 * the License, or (at your option) any later version.
013 *
014 * JBoss DNA is distributed in the hope that it will be useful,
015 * but WITHOUT ANY WARRANTY; without even the implied warranty of
016 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
017 * Lesser General Public License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this software; if not, write to the Free
021 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
022 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
023 */
024 package org.jboss.dna.sequencer.java;
025
026 import java.util.ArrayList;
027 import java.util.List;
028 import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
029 import org.eclipse.jdt.core.dom.Annotation;
030 import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
031 import org.eclipse.jdt.core.dom.ArrayType;
032 import org.eclipse.jdt.core.dom.CompilationUnit;
033 import org.eclipse.jdt.core.dom.EnumDeclaration;
034 import org.eclipse.jdt.core.dom.FieldDeclaration;
035 import org.eclipse.jdt.core.dom.IExtendedModifier;
036 import org.eclipse.jdt.core.dom.ImportDeclaration;
037 import org.eclipse.jdt.core.dom.MarkerAnnotation;
038 import org.eclipse.jdt.core.dom.MethodDeclaration;
039 import org.eclipse.jdt.core.dom.Modifier;
040 import org.eclipse.jdt.core.dom.NormalAnnotation;
041 import org.eclipse.jdt.core.dom.PackageDeclaration;
042 import org.eclipse.jdt.core.dom.ParameterizedType;
043 import org.eclipse.jdt.core.dom.PrimitiveType;
044 import org.eclipse.jdt.core.dom.SimpleType;
045 import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
046 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
047 import org.eclipse.jdt.core.dom.Type;
048 import org.eclipse.jdt.core.dom.TypeDeclaration;
049 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
050 import org.jboss.dna.common.util.CheckArg;
051 import org.jboss.dna.sequencer.java.metadata.ArrayTypeFieldMetadata;
052 import org.jboss.dna.sequencer.java.metadata.ClassMetadata;
053 import org.jboss.dna.sequencer.java.metadata.ConstructorMetadata;
054 import org.jboss.dna.sequencer.java.metadata.FieldMetadata;
055 import org.jboss.dna.sequencer.java.metadata.ImportMetadata;
056 import org.jboss.dna.sequencer.java.metadata.ImportOnDemandMetadata;
057 import org.jboss.dna.sequencer.java.metadata.InterfaceMetadata;
058 import org.jboss.dna.sequencer.java.metadata.MarkerAnnotationMetadata;
059 import org.jboss.dna.sequencer.java.metadata.MethodMetadata;
060 import org.jboss.dna.sequencer.java.metadata.MethodTypeMemberMetadata;
061 import org.jboss.dna.sequencer.java.metadata.ModifierMetadata;
062 import org.jboss.dna.sequencer.java.metadata.NormalAnnotationMetadata;
063 import org.jboss.dna.sequencer.java.metadata.PackageMetadata;
064 import org.jboss.dna.sequencer.java.metadata.ParameterizedTypeFieldMetadata;
065 import org.jboss.dna.sequencer.java.metadata.PrimitiveFieldMetadata;
066 import org.jboss.dna.sequencer.java.metadata.SimpleTypeFieldMetadata;
067 import org.jboss.dna.sequencer.java.metadata.SingleImportMetadata;
068 import org.jboss.dna.sequencer.java.metadata.SingleMemberAnnotationMetadata;
069 import org.jboss.dna.sequencer.java.metadata.TypeMetadata;
070 import org.jboss.dna.sequencer.java.metadata.Variable;
071
072 /**
073 * Abstract definition of a <code>JavaMetadata<code>. This class exposes some useful methods, that can
074 * be used to create meta data of a compilation unit. Methods can also separately be used.
075 *
076 * @author Serge Pagop
077 */
078 public abstract class AbstractJavaMetadata {
079
080 /**
081 * Create a set of <code>ImportMetadata</code> of a compilation unit.
082 *
083 * @param unit - the compilation unit.
084 * @return all static import declarations from the compilation unit.
085 */
086 @SuppressWarnings( "unchecked" )
087 protected List<ImportMetadata> createImportMetadata( CompilationUnit unit ) {
088 List<ImportMetadata> metadata = new ArrayList<ImportMetadata>();
089 List<ImportDeclaration> imports = unit.imports();
090 if (!imports.isEmpty()) {
091 for (ImportDeclaration importDeclaration : imports) {
092 if (importDeclaration.isOnDemand()) {
093 // typeImportOnDemand and staticImportOnDemand
094 ImportOnDemandMetadata onDemandMetadata = new ImportOnDemandMetadata();
095 onDemandMetadata.setName(JavaMetadataUtil.getName(importDeclaration.getName()));
096 metadata.add(onDemandMetadata);
097 } else {
098 // singleTypeImport and singleStaticImport
099 SingleImportMetadata singleImportMetadata = new SingleImportMetadata();
100 singleImportMetadata.setName(JavaMetadataUtil.getName(importDeclaration.getName()));
101 metadata.add(singleImportMetadata);
102 }
103
104 }
105 }
106 return metadata;
107 }
108
109 /**
110 * Create a <code>PackageMetadata</code> of a compilation unit.
111 *
112 * @param unit - the compilation unit.
113 * @return the package meta data of a compilation unit.
114 */
115 @SuppressWarnings( "unchecked" )
116 protected PackageMetadata createPackageMetadata( CompilationUnit unit ) {
117 PackageMetadata packageMetadata = null;
118 List<Annotation> annotations = null;
119 PackageDeclaration packageDeclaration = unit.getPackage();
120 if (packageDeclaration != null) {
121 annotations = packageDeclaration.annotations();
122 packageMetadata = new PackageMetadata();
123 packageMetadata.setName(JavaMetadataUtil.getName(unit.getPackage().getName()));
124 if (!annotations.isEmpty()) {
125 for (Object object : annotations) {
126
127 if (object instanceof NormalAnnotation) {
128 NormalAnnotation normalAnnotation = (NormalAnnotation)object;
129 NormalAnnotationMetadata normalAnnotationMetadata = new NormalAnnotationMetadata();
130 normalAnnotationMetadata.setName(JavaMetadataUtil.getName(normalAnnotation.getTypeName()));
131 normalAnnotationMetadata.setNormal(Boolean.TRUE);
132 packageMetadata.getAnnotationMetada().add(normalAnnotationMetadata);
133 }
134 if (object instanceof MarkerAnnotation) {
135 MarkerAnnotation markerAnnotation = (MarkerAnnotation)object;
136 MarkerAnnotationMetadata markerAnnotationMetadata = new MarkerAnnotationMetadata();
137 markerAnnotationMetadata.setName(JavaMetadataUtil.getName(markerAnnotation.getTypeName()));
138 markerAnnotationMetadata.setMarker(Boolean.TRUE);
139 packageMetadata.getAnnotationMetada().add(markerAnnotationMetadata);
140 }
141 if (object instanceof SingleMemberAnnotation) {
142 SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation)object;
143 SingleMemberAnnotationMetadata singleMemberAnnotationMetadata = new SingleMemberAnnotationMetadata();
144 singleMemberAnnotationMetadata.setName(JavaMetadataUtil.getName(singleMemberAnnotation.getTypeName()));
145 singleMemberAnnotationMetadata.setSingle(Boolean.TRUE);
146 packageMetadata.getAnnotationMetada().add(singleMemberAnnotationMetadata);
147
148 }
149 }
150 }
151 }
152 return packageMetadata;
153 }
154
155 /**
156 * Create a list with all top level types of a compilation unit.
157 *
158 * @param unit - the compilation unit.
159 * @return meta data for types in this compilation unit.
160 */
161 @SuppressWarnings( "unchecked" )
162 protected List<TypeMetadata> createTypeMetadata( CompilationUnit unit ) {
163 List<TypeMetadata> metadata = new ArrayList<TypeMetadata>();
164 List<AbstractTypeDeclaration> topLevelType = unit.types();
165
166 for (AbstractTypeDeclaration abstractTypeDeclaration : topLevelType) {
167 // process TypeDeclaration (class, interface)
168 if (abstractTypeDeclaration instanceof TypeDeclaration) {
169 TypeDeclaration typeDeclaration = (TypeDeclaration)abstractTypeDeclaration;
170 if (typeDeclaration.isInterface()) {
171 // is an interface top level type
172 InterfaceMetadata interfaceMetadata = new InterfaceMetadata();
173 interfaceMetadata.setName(JavaMetadataUtil.getName(typeDeclaration.getName()));
174 metadata.add(interfaceMetadata);
175 } else {
176 // is a class top level type
177 ClassMetadata classMetadata = new ClassMetadata();
178 processModifiersOfTypDeclaration(typeDeclaration, classMetadata);
179 classMetadata.setName(JavaMetadataUtil.getName(typeDeclaration.getName()));
180 // fields of the class top level type
181 FieldDeclaration[] fieldDeclarations = typeDeclaration.getFields();
182 for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
183 FieldMetadata fieldMetadata = getFieldMetadataFrom(fieldDeclaration);
184 classMetadata.getFields().add(fieldMetadata);
185 }
186 // methods of the class top level type
187 MethodDeclaration[] methodDeclarations = typeDeclaration.getMethods();
188 for (MethodDeclaration methodDeclaration : methodDeclarations) {
189 MethodMetadata methodMetadata = getMethodMetadataFrom(methodDeclaration);
190 classMetadata.getMethods().add(methodMetadata);
191 }
192 metadata.add(classMetadata);
193 }
194 }
195
196 // process EnumDeclaration
197 if (abstractTypeDeclaration instanceof EnumDeclaration) {
198 // EnumDeclaration enumDeclaration = (EnumDeclaration)abstractTypeDeclaration;
199 // TODO get infos from enum declaration and create a enum meta data object.
200 }
201
202 // process annotationTypeDeclaration
203 if (abstractTypeDeclaration instanceof AnnotationTypeDeclaration) {
204 // AnnotationTypeDeclaration annotationTypeDeclaration = (AnnotationTypeDeclaration)abstractTypeDeclaration;
205 // TODO get infos from annotation type declaration and create a annotation meta data object.
206 }
207 }
208 return metadata;
209 }
210
211 /**
212 * Process modifiers of {@link TypeDeclaration}.
213 *
214 * @param typeDeclaration - the type declaration.
215 * @param classMetadata - class meta data.
216 */
217 @SuppressWarnings( "unchecked" )
218 protected void processModifiersOfTypDeclaration( TypeDeclaration typeDeclaration,
219 ClassMetadata classMetadata ) {
220 List<IExtendedModifier> modifiers = typeDeclaration.modifiers();
221
222 for (IExtendedModifier extendedModifier : modifiers) {
223 ModifierMetadata modifierMetadata = new ModifierMetadata();
224 if (extendedModifier.isAnnotation()) {
225 if (extendedModifier instanceof MarkerAnnotation) {
226 MarkerAnnotation marker = (MarkerAnnotation)extendedModifier;
227 MarkerAnnotationMetadata markerAnnotationMetadata = new MarkerAnnotationMetadata();
228 markerAnnotationMetadata.setName(JavaMetadataUtil.getName(marker.getTypeName()));
229 classMetadata.getAnnotations().add(markerAnnotationMetadata);
230 }
231 } else {
232
233 Modifier modifier = (Modifier)extendedModifier;
234 modifierMetadata.setName(modifier.getKeyword().toString());
235 classMetadata.getModifiers().add(modifierMetadata);
236 }
237 }
238 }
239
240 /**
241 * Gets a method meta data from {@link MethodDeclaration}.
242 *
243 * @param methodDeclaration - the MethodDeclaration.
244 * @return methodMetadata - the method meta data.
245 */
246 protected MethodMetadata getMethodMetadataFrom( MethodDeclaration methodDeclaration ) {
247 if (methodDeclaration != null) {
248 if (methodDeclaration.isConstructor()) {
249 return getConstructorMetadataFrom(methodDeclaration);
250 }
251 return getMethodTypeMemberMetadataFrom(methodDeclaration);
252
253 }
254 return null;
255 }
256
257 /**
258 * Get {@link MethodTypeMemberMetadata}
259 *
260 * @param methodDeclaration
261 * @return methodTypeMemberMetadata
262 */
263 @SuppressWarnings( "unchecked" )
264 protected MethodMetadata getMethodTypeMemberMetadataFrom( MethodDeclaration methodDeclaration ) {
265 MethodTypeMemberMetadata methodTypeMemberMetadata = new MethodTypeMemberMetadata();
266 processReturnTypeOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
267 processModifiersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
268 processParametersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
269 methodTypeMemberMetadata.setName(JavaMetadataUtil.getName(methodDeclaration.getName()));
270 List<SingleVariableDeclaration> params = methodDeclaration.parameters();
271 for (SingleVariableDeclaration singleVariableDeclaration : params) {
272 singleVariableDeclaration.getName();
273 }
274 return methodTypeMemberMetadata;
275 }
276
277 /**
278 * Process return type of a {@link MethodDeclaration}.
279 *
280 * @param methodDeclaration - the method declaration.
281 * @param methodMetadata - the method meta data.
282 */
283 protected void processReturnTypeOfMethodDeclaration( MethodDeclaration methodDeclaration,
284 MethodMetadata methodMetadata ) {
285 Type type = methodDeclaration.getReturnType2();
286 if (type.isPrimitiveType()) {
287 PrimitiveFieldMetadata primitive = new PrimitiveFieldMetadata();
288 primitive.setType(((PrimitiveType)type).getPrimitiveTypeCode().toString());
289 methodMetadata.setReturnType(primitive);
290 }
291 if (type.isSimpleType()) {
292 SimpleTypeFieldMetadata simpleTypeFieldMetadata = new SimpleTypeFieldMetadata();
293 simpleTypeFieldMetadata.setType(JavaMetadataUtil.getName(((SimpleType)type).getName()));
294 methodMetadata.setReturnType(simpleTypeFieldMetadata);
295 }
296 }
297
298 /**
299 * Process parameters of a {@link MethodDeclaration}.
300 *
301 * @param methodDeclaration - the method declaration.
302 * @param methodMetadata - the method meta data.
303 */
304 @SuppressWarnings( "unchecked" )
305 protected void processParametersOfMethodDeclaration( MethodDeclaration methodDeclaration,
306 MethodMetadata methodMetadata ) {
307 for (SingleVariableDeclaration singleVariableDeclaration : (List<SingleVariableDeclaration>)methodDeclaration.parameters()) {
308 Type type = singleVariableDeclaration.getType();
309 if (type.isPrimitiveType()) {
310 PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)processVariableDeclaration(singleVariableDeclaration,
311 type);
312 methodMetadata.getParameters().add(primitiveFieldMetadata);
313 }
314 if (type.isParameterizedType()) {
315 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration,
316 type);
317 methodMetadata.getParameters().add(parameterizedTypeFieldMetadata);
318 }
319 if (type.isQualifiedType()) {
320 // TODO
321 }
322 if (type.isSimpleType()) {
323 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration, type);
324 methodMetadata.getParameters().add(simpleTypeFieldMetadata);
325 }
326 if (type.isArrayType()) {
327 ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration, type);
328 methodMetadata.getParameters().add(arrayTypeFieldMetadata);
329 }
330 if (type.isWildcardType()) {
331 // TODO
332 }
333 }
334
335 }
336
337 /**
338 * Process a {@link SingleVariableDeclaration} of a {@link MethodDeclaration}.
339 *
340 * @param singleVariableDeclaration
341 * @param type
342 * @return a field meta data.
343 */
344 @SuppressWarnings( "unchecked" )
345 private FieldMetadata processVariableDeclaration( SingleVariableDeclaration singleVariableDeclaration,
346 Type type ) {
347
348 Variable variable;
349 if (type.isPrimitiveType()) {
350 PrimitiveFieldMetadata primitiveFieldMetadata = new PrimitiveFieldMetadata();
351 primitiveFieldMetadata.setType(((PrimitiveType)type).getPrimitiveTypeCode().toString());
352 variable = new Variable();
353 variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName()));
354 primitiveFieldMetadata.getVariables().add(variable);
355 for (IExtendedModifier extendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) {
356 ModifierMetadata modifierMetadata = new ModifierMetadata();
357 if (extendedModifier.isAnnotation()) {
358 // TODO
359 } else {
360 Modifier modifier = (Modifier)extendedModifier;
361 modifierMetadata.setName(modifier.getKeyword().toString());
362 primitiveFieldMetadata.getModifiers().add(modifierMetadata);
363 }
364 }
365 return primitiveFieldMetadata;
366 }
367 if(type.isSimpleType()) {
368 SimpleType simpleType = (SimpleType)type;
369 SimpleTypeFieldMetadata simpleTypeFieldMetadata = new SimpleTypeFieldMetadata();
370 simpleTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName()));
371 variable = new Variable();
372 variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName()));
373 simpleTypeFieldMetadata.getVariables().add(variable);
374 for (IExtendedModifier simpleTypeExtendedModifier : (List<IExtendedModifier> )singleVariableDeclaration.modifiers()) {
375 ModifierMetadata modifierMetadata = new ModifierMetadata();
376 if (simpleTypeExtendedModifier.isAnnotation()) {
377 // TODO
378 } else {
379 Modifier modifier = (Modifier)simpleTypeExtendedModifier;
380 modifierMetadata.setName(modifier.getKeyword().toString());
381 simpleTypeFieldMetadata.getModifiers().add(modifierMetadata);
382 }
383 }
384 return simpleTypeFieldMetadata;
385 }
386 if (type.isParameterizedType()) {
387 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = new ParameterizedTypeFieldMetadata();
388 ParameterizedType parameterizedType = (ParameterizedType)type;
389 parameterizedTypeFieldMetadata.setType(getTypeName(parameterizedType));
390 variable = new Variable();
391 variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName()));
392 parameterizedTypeFieldMetadata.getVariables().add(variable);
393 for (IExtendedModifier parameterizedExtendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) {
394 ModifierMetadata modifierMetadata = new ModifierMetadata();
395 if(parameterizedExtendedModifier.isAnnotation()) {
396 // TODO
397 } else {
398 Modifier modifier = (Modifier)parameterizedExtendedModifier;
399 modifierMetadata.setName(modifier.getKeyword().toString());
400 parameterizedTypeFieldMetadata.getModifiers().add(modifierMetadata);
401 }
402 }
403 return parameterizedTypeFieldMetadata;
404 }
405 if(type.isArrayType()) {
406 ArrayTypeFieldMetadata arrayTypeFieldMetadata = new ArrayTypeFieldMetadata();
407 ArrayType arrayType = (ArrayType)type;
408 arrayTypeFieldMetadata.setType(getTypeName(arrayType));
409 variable = new Variable();
410 variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName()));
411 arrayTypeFieldMetadata.getVariables().add(variable);
412
413 for (IExtendedModifier arrayTypeExtendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) {
414 ModifierMetadata modifierMetadata = new ModifierMetadata();
415 if(arrayTypeExtendedModifier.isAnnotation()) {
416 // TODO
417 } else {
418 Modifier modifier = (Modifier)arrayTypeExtendedModifier;
419 modifierMetadata.setName(modifier.getKeyword().toString());
420 arrayTypeFieldMetadata.getModifiers().add(modifierMetadata);
421 }
422 }
423 return arrayTypeFieldMetadata;
424 }
425 return null;
426 }
427
428 /**
429 * Extract the type name
430 *
431 * @param type - the type to be processed. This can be primitive, simple, parameterized ...
432 * @return the name of a type.
433 * @throws IllegalArgumentException if type is null.
434 */
435 private String getTypeName( Type type ) {
436 CheckArg.isNotNull(type, "type");
437 if (type.isPrimitiveType()) {
438 PrimitiveType primitiveType = (PrimitiveType)type;
439 return primitiveType.getPrimitiveTypeCode().toString();
440 }
441 if (type.isSimpleType()) {
442 SimpleType simpleType = (SimpleType)type;
443 return JavaMetadataUtil.getName(simpleType.getName());
444 }
445 if(type.isArrayType()) {
446 ArrayType arrayType = (ArrayType)type;
447 // the element type is never an array type
448 Type elementType = arrayType.getElementType();
449 if (elementType.isPrimitiveType()) {
450 return ((PrimitiveType)elementType).getPrimitiveTypeCode().toString();
451
452 }
453 // can't be an array type
454 if (elementType.isSimpleType()) {
455 return JavaMetadataUtil.getName(((SimpleType)elementType).getName());
456 }
457
458 }
459 return null;
460 }
461
462 /**
463 * Get {@link ConstructorMetadata}
464 *
465 * @param methodDeclaration
466 * @return constructorMetadata
467 */
468 protected MethodMetadata getConstructorMetadataFrom( MethodDeclaration methodDeclaration ) {
469 ConstructorMetadata constructorMetadata = new ConstructorMetadata();
470 // modifiers
471 processModifiersOfMethodDeclaration(methodDeclaration, constructorMetadata);
472 processParametersOfMethodDeclaration(methodDeclaration, constructorMetadata);
473 constructorMetadata.setName(JavaMetadataUtil.getName(methodDeclaration.getName()));
474 // arguments list
475 return constructorMetadata;
476 }
477
478 /**
479 * Gets a field meta data from {@link FieldDeclaration}.
480 *
481 * @param fieldDeclaration - the declaration.
482 * @return fieldMetadata - meta data.
483 */
484 protected FieldMetadata getFieldMetadataFrom( FieldDeclaration fieldDeclaration ) {
485 if (fieldDeclaration != null && fieldDeclaration.getType() != null && (!fieldDeclaration.fragments().isEmpty())) {
486 // type
487 Type type = fieldDeclaration.getType();
488 // Primitive type
489 if (type.isPrimitiveType()) {
490 PrimitiveFieldMetadata primitiveFieldMetadata = processPrimitiveType(fieldDeclaration);
491 return primitiveFieldMetadata;
492 }
493 // ParameterizedType
494 if (type.isParameterizedType()) {
495 ParameterizedTypeFieldMetadata referenceFieldMetadata = processParameterizedType(fieldDeclaration);
496 return referenceFieldMetadata;
497 }
498 // SimpleType
499 if (type.isSimpleType()) {
500 SimpleTypeFieldMetadata simpleTypeFieldMetadata = processSimpleType(fieldDeclaration);
501 return simpleTypeFieldMetadata;
502 }
503 // ArrayType
504 if (type.isArrayType()) {
505 ArrayTypeFieldMetadata arrayFieldMetadata = processArrayTypeFrom(fieldDeclaration);
506 return arrayFieldMetadata;
507 }
508 // QualifiedType
509 if (type.isQualifiedType()) {
510 // TODO
511
512 }
513 // WildcardType
514 if (type.isWildcardType()) {
515
516 }
517 }
518 return null;
519 }
520
521 /**
522 * Process a {@link FieldDeclaration} to win information for an array type.
523 *
524 * @param fieldDeclaration - field declaration
525 * @return an ArrayTypeFieldMetadata, that contains information about an array type.
526 */
527 protected ArrayTypeFieldMetadata processArrayTypeFrom( FieldDeclaration fieldDeclaration ) {
528 ArrayTypeFieldMetadata arrayTypeFieldMetadata = null;
529 ArrayType arrayType = (ArrayType)fieldDeclaration.getType();
530 // the element type is never an array type
531 Type type = arrayType.getElementType();
532 if (type.isPrimitiveType()) {
533 PrimitiveType primitiveType = (PrimitiveType)type;
534 arrayTypeFieldMetadata = new ArrayTypeFieldMetadata();
535 arrayTypeFieldMetadata.setType(primitiveType.getPrimitiveTypeCode().toString());
536 processModifiersAndVariablesOfFieldDeclaration(fieldDeclaration, arrayTypeFieldMetadata);
537 return arrayTypeFieldMetadata;
538
539 }
540 // can't be an array type
541 if (type.isSimpleType()) {
542 SimpleType simpleType = (SimpleType)type;
543 arrayTypeFieldMetadata = new ArrayTypeFieldMetadata();
544 arrayTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName()));
545 processModifiersAndVariablesOfFieldDeclaration(fieldDeclaration, arrayTypeFieldMetadata);
546 return arrayTypeFieldMetadata;
547 }
548
549 return null;
550 }
551
552 /**
553 * Process together modifiers and variables of a {@link FieldDeclaration}.
554 *
555 * @param fieldDeclaration - the field declaration instance.
556 * @param arrayTypeFieldMetadata - the meta data.
557 */
558 private void processModifiersAndVariablesOfFieldDeclaration( FieldDeclaration fieldDeclaration,
559 ArrayTypeFieldMetadata arrayTypeFieldMetadata ) {
560 processModifiersOfFieldDeclaration(fieldDeclaration, arrayTypeFieldMetadata);
561 processVariablesOfVariableDeclarationFragment(fieldDeclaration, arrayTypeFieldMetadata);
562 }
563
564 /**
565 * Process the simple type of a {@link FieldDeclaration}.
566 *
567 * @param fieldDeclaration - the field declaration.
568 * @return SimpleTypeFieldMetadata.
569 */
570 protected SimpleTypeFieldMetadata processSimpleType( FieldDeclaration fieldDeclaration ) {
571 SimpleType simpleType = (SimpleType)fieldDeclaration.getType();
572 SimpleTypeFieldMetadata simpleTypeFieldMetadata = new SimpleTypeFieldMetadata();
573 simpleTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName()));
574 // modifiers
575 processModifiersOfFieldDeclaration(fieldDeclaration, simpleTypeFieldMetadata);
576 processVariablesOfVariableDeclarationFragment(fieldDeclaration, simpleTypeFieldMetadata);
577 return simpleTypeFieldMetadata;
578 }
579
580 /**
581 * Process the parameterized type of a {@link FieldDeclaration}.
582 *
583 * @param fieldDeclaration - the field declaration.
584 * @return ParameterizedTypeFieldMetadata.
585 */
586 protected ParameterizedTypeFieldMetadata processParameterizedType( FieldDeclaration fieldDeclaration ) {
587 ParameterizedType parameterizedType = (ParameterizedType)fieldDeclaration.getType();
588 Type typeOfParameterizedType = parameterizedType.getType(); // type may be a simple type or a qualified type.
589 ParameterizedTypeFieldMetadata referenceFieldMetadata = (ParameterizedTypeFieldMetadata)createParameterizedFieldMetadataFrom(typeOfParameterizedType);
590 // modifiers
591 processModifiersOfFieldDeclaration(fieldDeclaration, referenceFieldMetadata);
592 // variables
593 processVariablesOfVariableDeclarationFragment(fieldDeclaration, referenceFieldMetadata);
594 return referenceFieldMetadata;
595 }
596
597 /**
598 * Process the primitive type of a {@link FieldDeclaration}.
599 *
600 * @param fieldDeclaration - the field declaration.
601 * @return PrimitiveFieldMetadata.
602 */
603 protected PrimitiveFieldMetadata processPrimitiveType( FieldDeclaration fieldDeclaration ) {
604 PrimitiveType primitiveType = (PrimitiveType)fieldDeclaration.getType();
605 PrimitiveFieldMetadata primitiveFieldMetadata = new PrimitiveFieldMetadata();
606 primitiveFieldMetadata.setType(primitiveType.getPrimitiveTypeCode().toString());
607 // modifiers
608 processModifiersOfFieldDeclaration(fieldDeclaration, primitiveFieldMetadata);
609 // variables
610 processVariablesOfVariableDeclarationFragment(fieldDeclaration, primitiveFieldMetadata);
611 return primitiveFieldMetadata;
612 }
613
614 /**
615 * Process modifiers of a {@link FieldDeclaration}
616 *
617 * @param fieldDeclaration
618 * @param fieldMetadata
619 */
620 @SuppressWarnings( "unchecked" )
621 protected void processModifiersOfFieldDeclaration( FieldDeclaration fieldDeclaration,
622 FieldMetadata fieldMetadata ) {
623 List<IExtendedModifier> extendedModifiers = fieldDeclaration.modifiers();
624 for (IExtendedModifier extendedModifier : extendedModifiers) {
625 ModifierMetadata modifierMetadata = new ModifierMetadata();
626 if (extendedModifier.isAnnotation()) {
627 // TODO annotation modifiers
628 } else {
629 Modifier modifier = (Modifier)extendedModifier;
630 modifierMetadata.setName(modifier.getKeyword().toString());
631 fieldMetadata.getModifiers().add(modifierMetadata);
632 }
633 }
634
635 }
636
637 /**
638 * Process modifiers of a {@link MethodDeclaration}.
639 *
640 * @param methodDeclaration
641 * @param methodMetadata
642 */
643 @SuppressWarnings( "unchecked" )
644 protected void processModifiersOfMethodDeclaration( MethodDeclaration methodDeclaration,
645 MethodMetadata methodMetadata ) {
646 List<IExtendedModifier> extendedModifiers = methodDeclaration.modifiers();
647 for (IExtendedModifier extendedModifier : extendedModifiers) {
648 ModifierMetadata modifierMetadata = new ModifierMetadata();
649 if (extendedModifier.isAnnotation()) {
650 // TODO
651 } else {
652 Modifier modifier = (Modifier)extendedModifier;
653 modifierMetadata.setName(modifier.getKeyword().toString());
654 methodMetadata.getModifiers().add(modifierMetadata);
655 }
656 }
657 }
658
659 /**
660 * Create a <code>FieldMetadata</code> from a {@link Type} instance.
661 *
662 * @param type - The {@link Type}
663 * @return the specific type of <code>FieldMetadata</code>
664 */
665 protected FieldMetadata createParameterizedFieldMetadataFrom( Type type ) {
666 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = null;
667 if (type.isSimpleType()) {
668 SimpleType simpleType = (SimpleType)type;
669 parameterizedTypeFieldMetadata = new ParameterizedTypeFieldMetadata();
670 parameterizedTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName()));
671 }
672 // TODO also process QualifiedType
673 return parameterizedTypeFieldMetadata;
674 }
675
676 /**
677 * Process variables of a {@link VariableDeclarationFragment}.
678 *
679 * @param fieldDeclaration - the {@link FieldDeclaration}
680 * @param fieldMetadata - where to transfer the meta data.
681 */
682 @SuppressWarnings( "unchecked" )
683 protected void processVariablesOfVariableDeclarationFragment( FieldDeclaration fieldDeclaration,
684 FieldMetadata fieldMetadata ) {
685 List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
686 for (VariableDeclarationFragment fragment : fragments) {
687 fieldMetadata.getVariables().add(new Variable(JavaMetadataUtil.getName(fragment.getName())));
688 }
689 }
690 }