1 /*
2 * ModeShape (http://www.modeshape.org)
3 * See the COPYRIGHT.txt file distributed with this work for information
4 * regarding copyright ownership. Some portions may be licensed
5 * to Red Hat, Inc. under one or more contributor license agreements.
6 * See the AUTHORS.txt file in the distribution for a full listing of
7 * individual contributors.
8 *
9 * ModeShape is free software. Unless otherwise indicated, all code in ModeShape
10 * is licensed to you under the terms of the GNU Lesser General Public License as
11 * published by the Free Software Foundation; either version 2.1 of
12 * the License, or (at your option) any later version.
13 *
14 * ModeShape is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this software; if not, write to the Free
21 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
23 */
24 package org.modeshape.sequencer.java;
25
26 import java.util.List;
27 import org.modeshape.graph.JcrLexicon;
28 import org.modeshape.graph.property.NameFactory;
29 import org.modeshape.graph.property.Path;
30 import org.modeshape.graph.property.PathFactory;
31 import org.modeshape.graph.sequencer.SequencerOutput;
32 import org.modeshape.graph.sequencer.StreamSequencerContext;
33 import org.modeshape.sequencer.java.metadata.AnnotationMetadata;
34 import org.modeshape.sequencer.java.metadata.ArrayTypeFieldMetadata;
35 import org.modeshape.sequencer.java.metadata.ClassMetadata;
36 import org.modeshape.sequencer.java.metadata.ConstructorMetadata;
37 import org.modeshape.sequencer.java.metadata.FieldMetadata;
38 import org.modeshape.sequencer.java.metadata.ImportMetadata;
39 import org.modeshape.sequencer.java.metadata.ImportOnDemandMetadata;
40 import org.modeshape.sequencer.java.metadata.JavaMetadata;
41 import org.modeshape.sequencer.java.metadata.MarkerAnnotationMetadata;
42 import org.modeshape.sequencer.java.metadata.MethodMetadata;
43 import org.modeshape.sequencer.java.metadata.MethodTypeMemberMetadata;
44 import org.modeshape.sequencer.java.metadata.ModifierMetadata;
45 import org.modeshape.sequencer.java.metadata.NormalAnnotationMetadata;
46 import org.modeshape.sequencer.java.metadata.PackageMetadata;
47 import org.modeshape.sequencer.java.metadata.ParameterizedTypeFieldMetadata;
48 import org.modeshape.sequencer.java.metadata.PrimitiveFieldMetadata;
49 import org.modeshape.sequencer.java.metadata.QualifiedTypeFieldMetadata;
50 import org.modeshape.sequencer.java.metadata.SimpleTypeFieldMetadata;
51 import org.modeshape.sequencer.java.metadata.SingleImportMetadata;
52 import org.modeshape.sequencer.java.metadata.SingleMemberAnnotationMetadata;
53 import org.modeshape.sequencer.java.metadata.TypeMetadata;
54 import org.modeshape.sequencer.java.metadata.Variable;
55
56 /**
57 * A source file recorder that writes the Java metadata from the source file to the repository.
58 * <p>
59 * The structural representation of the informations from the compilation unit looks like this:
60 * <ul>
61 * <li><strong>java:compilationUnit</strong> node of type <code>java:compilationUnit</code>
62 * <ul>
63 * <li> <strong>java:package</strong> - optional child node that represents the package child node of the compilation unit.
64 * <ul>
65 * <li> <strong>java:packageDeclaration</strong> - the package declaration.
66 * <ul>
67 * <li><strong>java:packageName</strong></li> - the package name.
68 * </ul>
69 * </li>
70 * </ul>
71 * </li>
72 * <li> <strong>java:import</strong> - optional child node that represents the import declaration of the compilation unit
73 * <ul>
74 * <li> <strong>java:importDeclaration</strong> - the import declaration
75 * <ul>
76 * <li><strong>java:singleImport</strong>
77 * <ul>
78 * <li> <strong>java:singleTypeImportDeclaration</strong>
79 * <ul>
80 * <li> <strong>java:singleTypeImportkeyword</strong> - the keyword "import"
81 * <li><strong>java:singleImportName</strong></li> - the name of a single import. </li>
82 * </ul>
83 * </li>
84 * </ul>
85 * </li>
86 * <li><strong>java:importOnDemand</strong>
87 * <li> <strong>java:typeImportOnDemandDeclaration</strong>
88 * <ul>
89 * <li> <strong>java:onDemandImportKeyword</strong> - the keyword "import"
90 * <li><strong>java:onDemandImportName</strong></li> - the name of the on demand import. </li>
91 * </ul>
92 * </li>
93 * </i>
94 * </ul>
95 * </li>
96 * </ul>
97 * </li>
98 * <li><strong>java:unitType</strong> - optional child node that represents the top level type (class, interface, enum,
99 * annotation) declaration of the compilation unit</li>
100 * <ul>
101 * <li> <strong>java:classDeclaration</strong> - optional child node that represents the class declaration of the compilation
102 * unit
103 * <ul>
104 * <li> <strong>java:normalClass</strong> - the normal class.
105 * <ul>
106 * <li> <strong>java:normalClassDeclaration</strong> - the normal class declaration
107 * <ul>
108 * <li> <strong>java:modifier</strong> - modifier child node.
109 * <ul>
110 * <li><strong>java:modifierDeclaration</strong> - the modifier declaration.
111 * <ul>
112 * <li><strong>java:modifierName</strong> - modifier name.</li>
113 * </ul>
114 * </li>
115 * </ul>
116 * </li>
117 * <li> <strong>java:normalClassName</strong> - class name.</li>
118 * <li> <strong>java:field</strong> - field child node.
119 * <ul>
120 * <li><strong>java:fieldType</strong> - field type child node.
121 * <ul>
122 * <li><strong>java:type</strong> - type child node.
123 * <ul>
124 * <li>[java:primitiveType, java:simpleType, java:parameterizedType] - can be primitive type or simple type and or parameterized
125 * type<.</li>
126 * </ul>
127 * </li>
128 * </ul>
129 * </li>
130 * </ul>
131 * </li>
132 * <li> <strong>java:constructor</strong> - the constructor child node
133 * <ul>
134 * <li><strong>java:constructorDeclaration</strong> - the constructor declaration.
135 * <ul>
136 * <li><strong>java:constructorName</strong> - constructor name. </li>
137 * <li><strong>java:modifier </strong> - the modifier child node.</li> +
138 * <li><strong>java:parameter </strong> - the parameter child node</li>
139 * </ul>
140 * </li>
141 * </ul>
142 * </li>
143 * <li> <strong>java:method</strong> - method child node.
144 * <ul>
145 * <li></strong>java:methodDeclaration</strong> - method declaration.
146 * <ul>
147 * <li><strong>java:methodName </strong> - method name. </li>
148 * <li><strong>java:modifier </strong> - the modifier child node.</li> +
149 * <li><strong>java:resultType </strong> - the result type child node </li> +
150 * <li><strong>java:parameter </strong> - the parameter child node</li>
151 * </ul>
152 * </li>
153 * </ul>
154 * </li>
155 * </ul>
156 * </li>
157 * </ul>
158 * </li>
159 * </ul>
160 * </li>
161 * </ul>
162 * </li>
163 * </ul>
164 * </p>
165 */
166 public class OriginalFormatSourceFileRecorder implements SourceFileRecorder {
167
168 public void record( StreamSequencerContext context,
169 SequencerOutput output,
170 JavaMetadata javaMetadata ) {
171 NameFactory nameFactory = context.getValueFactories().getNameFactory();
172 PathFactory pathFactory = context.getValueFactories().getPathFactory();
173
174 if (javaMetadata != null) {
175 Path javaCompilationUnitNode = pathFactory.create(JavaMetadataLexicon.COMPILATION_UNIT_NODE);
176 output.setProperty(javaCompilationUnitNode, JcrLexicon.PRIMARY_TYPE, JavaMetadataLexicon.COMPILATION_UNIT_NODE);
177
178 // sequence package declaration of a unit.
179 PackageMetadata packageMetadata = javaMetadata.getPackageMetadata();
180 if (packageMetadata != null) {
181 String packageName = packageMetadata.getName();
182 if (packageName != null && packageName.length() != 0) {
183
184 Path javaPackageDeclarationChildNode = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
185 JavaMetadataLexicon.PACKAGE_CHILD_NODE,
186 JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE);
187 output.setProperty(javaPackageDeclarationChildNode,
188 JavaMetadataLexicon.PACKAGE_NAME,
189 javaMetadata.getPackageMetadata().getName());
190 }
191
192 int markerAnnotationIndex = 1;
193 int singleAnnatationIndex = 1;
194 int normalAnnotationIndex = 1;
195 for (AnnotationMetadata annotationMetadata : packageMetadata.getAnnotationMetada()) {
196 if (annotationMetadata instanceof MarkerAnnotationMetadata) {
197 MarkerAnnotationMetadata markerAnnotationMetadata = (MarkerAnnotationMetadata)annotationMetadata;
198 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
199 JavaMetadataLexicon.PACKAGE_CHILD_NODE,
200 JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE,
201 JavaMetadataLexicon.ANNOTATION_CHILD_NODE,
202 JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE,
203 JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE);
204
205 Path markerAnnotationChildNode = pathFactory.create(basePath,
206 pathFactory.createSegment(JavaMetadataLexicon.MARKER_ANNOTATION_CHILD_NODE,
207 markerAnnotationIndex));
208 output.setProperty(markerAnnotationChildNode,
209 JavaMetadataLexicon.MARKER_ANNOTATION_NAME,
210 markerAnnotationMetadata.getName());
211 markerAnnotationIndex++;
212 }
213 if (annotationMetadata instanceof SingleMemberAnnotationMetadata) {
214 SingleMemberAnnotationMetadata singleMemberAnnotationMetadata = (SingleMemberAnnotationMetadata)annotationMetadata;
215
216 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
217 JavaMetadataLexicon.PACKAGE_CHILD_NODE,
218 JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE,
219 JavaMetadataLexicon.ANNOTATION_CHILD_NODE,
220 JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE,
221 JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE);
222
223 Path singleMemberAnnotationChildNode = pathFactory.create(basePath,
224 pathFactory.createSegment(JavaMetadataLexicon.SINGLE_ELEMENT_ANNOTATION_CHILD_NODE,
225 singleAnnatationIndex));
226 output.setProperty(singleMemberAnnotationChildNode,
227 JavaMetadataLexicon.SINGLE_ANNOTATION_NAME,
228 singleMemberAnnotationMetadata.getName());
229 singleAnnatationIndex++;
230 }
231 if (annotationMetadata instanceof NormalAnnotationMetadata) {
232 NormalAnnotationMetadata normalAnnotationMetadata = (NormalAnnotationMetadata)annotationMetadata;
233 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
234 JavaMetadataLexicon.PACKAGE_CHILD_NODE,
235 JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE,
236 JavaMetadataLexicon.ANNOTATION_CHILD_NODE,
237 JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE,
238 JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE);
239
240 Path normalAnnotationChildNode = pathFactory.create(basePath,
241 pathFactory.createSegment(JavaMetadataLexicon.NORMAL_ANNOTATION_CHILD_NODE,
242 normalAnnotationIndex));
243
244 output.setProperty(normalAnnotationChildNode,
245 JavaMetadataLexicon.NORMALANNOTATION_NAME,
246 normalAnnotationMetadata.getName());
247 normalAnnotationIndex++;
248 }
249 }
250 }
251
252 // sequence import declarations of a unit
253 int importOnDemandIndex = 1;
254 int singleImportIndex = 1;
255 for (ImportMetadata importMetadata : javaMetadata.getImports()) {
256 if (importMetadata instanceof ImportOnDemandMetadata) {
257 ImportOnDemandMetadata importOnDemandMetadata = (ImportOnDemandMetadata)importMetadata;
258
259 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
260 JavaMetadataLexicon.IMPORT_CHILD_NODE,
261 JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE,
262 JavaMetadataLexicon.ON_DEMAND_IMPORT_CHILD_NODE);
263
264 Path importOnDemandChildNode = pathFactory.create(basePath,
265 pathFactory.createSegment(JavaMetadataLexicon.ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE,
266 importOnDemandIndex));
267 output.setProperty(importOnDemandChildNode,
268 JavaMetadataLexicon.ON_DEMAND_IMPORT_NAME,
269 importOnDemandMetadata.getName());
270 importOnDemandIndex++;
271 }
272 if (importMetadata instanceof SingleImportMetadata) {
273 SingleImportMetadata singleImportMetadata = (SingleImportMetadata)importMetadata;
274
275 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
276 JavaMetadataLexicon.IMPORT_CHILD_NODE,
277 JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE,
278 JavaMetadataLexicon.SINGLE_IMPORT_CHILD_NODE);
279
280 Path singleImportChildNode = pathFactory.create(basePath,
281 pathFactory.createSegment(JavaMetadataLexicon.SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE,
282 importOnDemandIndex));
283 output.setProperty(singleImportChildNode,
284 JavaMetadataLexicon.SINGLE_IMPORT_NAME,
285 singleImportMetadata.getName());
286 singleImportIndex++;
287 }
288 }
289
290 // sequence type declaration (class declaration) information
291 for (TypeMetadata typeMetadata : javaMetadata.getTypeMetadata()) {
292 // class declaration
293 if (typeMetadata instanceof ClassMetadata) {
294
295 Path normalClassRootPath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
296 JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE,
297 JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE,
298 JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE,
299 JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE);
300
301 ClassMetadata classMetadata = (ClassMetadata)typeMetadata;
302 output.setProperty(normalClassRootPath, JavaMetadataLexicon.NORMAL_CLASS_NAME, classMetadata.getName());
303
304 // process modifiers of the class declaration
305 List<ModifierMetadata> classModifiers = classMetadata.getModifiers();
306 int modifierIndex = 1;
307 for (ModifierMetadata modifierMetadata : classModifiers) {
308
309 Path basePath = pathFactory.create(normalClassRootPath, JavaMetadataLexicon.MODIFIER_CHILD_NODE);
310
311 Path classModifierChildNode = pathFactory.create(basePath,
312 pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE,
313 modifierIndex));
314
315 output.setProperty(classModifierChildNode, JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName());
316 }
317
318 // process fields of the class unit.
319 int primitiveIndex = 1;
320 int simpleIndex = 1;
321 int parameterizedIndex = 1;
322 int arrayIndex = 1;
323 for (FieldMetadata fieldMetadata : classMetadata.getFields()) {
324 Path fieldMemberDataRootPath = pathFactory.create(normalClassRootPath,
325 JavaMetadataLexicon.FIELD_CHILD_NODE,
326 JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE,
327 JavaMetadataLexicon.TYPE_CHILD_NODE);
328 if (fieldMetadata instanceof PrimitiveFieldMetadata) {
329 // primitive type
330 PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fieldMetadata;
331 Path primitiveFieldRootPath = pathFactory.create(fieldMemberDataRootPath,
332 pathFactory.createSegment(JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE,
333 primitiveIndex));
334 // type
335 output.setProperty(primitiveFieldRootPath,
336 JavaMetadataLexicon.PRIMITIVE_TYPE_NAME,
337 primitiveFieldMetadata.getType());
338 // modifiers
339 List<ModifierMetadata> modifiers = primitiveFieldMetadata.getModifiers();
340 int primitiveModifierIndex = 1;
341 for (ModifierMetadata modifierMetadata : modifiers) {
342 Path modifierPath = pathFactory.create(pathFactory.create(primitiveFieldRootPath,
343 JavaMetadataLexicon.MODIFIER_CHILD_NODE),
344 pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE,
345 primitiveModifierIndex));
346 output.setProperty(modifierPath, JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName());
347 primitiveModifierIndex++;
348 }
349 // variables
350 List<Variable> variables = primitiveFieldMetadata.getVariables();
351 int primitiveVariableIndex = 1;
352 for (Variable variable : variables) {
353 Path variablePath = pathFactory.create(pathFactory.create(primitiveFieldRootPath,
354 JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE),
355 pathFactory.createSegment(JavaMetadataLexicon.VARIABLE,
356 primitiveVariableIndex));
357 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, variablePath);
358 primitiveVariableIndex++;
359 }
360 primitiveIndex++;
361 }
362
363 // Array type
364 if (fieldMetadata instanceof ArrayTypeFieldMetadata) {
365 ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata;
366 Path arrayTypeRootPath = pathFactory.create(fieldMemberDataRootPath,
367 pathFactory.createSegment(JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE,
368 arrayIndex));
369 ArrayTypeFieldMetadataSequencer.sequenceFieldMemberData(arrayTypeFieldMetadata,
370 pathFactory,
371 nameFactory,
372 output,
373 arrayTypeRootPath,
374 arrayIndex);
375 arrayIndex++;
376 }
377
378 // Simple type
379 if (fieldMetadata instanceof SimpleTypeFieldMetadata) {
380 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata;
381 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
382 JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE,
383 JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE,
384 JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE,
385 JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE,
386 JavaMetadataLexicon.FIELD_CHILD_NODE,
387 JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE,
388 JavaMetadataLexicon.TYPE_CHILD_NODE);
389
390 Path simpleTypeFieldRootPath = pathFactory.create(basePath,
391 pathFactory.createSegment(JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE,
392 simpleIndex));
393 output.setProperty(simpleTypeFieldRootPath,
394 JavaMetadataLexicon.SIMPLE_TYPE_NAME,
395 simpleTypeFieldMetadata.getType());
396
397 // Simple type modifies
398 List<ModifierMetadata> simpleModifiers = simpleTypeFieldMetadata.getModifiers();
399 int simpleTypeModifierIndex = 1;
400 for (ModifierMetadata modifierMetadata : simpleModifiers) {
401 Path simpleTypeModifierPath = pathFactory.create(pathFactory.create(simpleTypeFieldRootPath,
402 JavaMetadataLexicon.SIMPLE_TYPE_MODIFIER_CHILD_NODE),
403 pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE,
404 simpleTypeModifierIndex));
405 output.setProperty(simpleTypeModifierPath,
406 JavaMetadataLexicon.MODIFIER_NAME,
407 modifierMetadata.getName());
408 simpleTypeModifierIndex++;
409 }
410
411 // Simple type variables
412 List<Variable> variables = simpleTypeFieldMetadata.getVariables();
413 int simpleTypeVariableIndex = 1;
414 for (Variable variable : variables) {
415 Path variablePath = pathFactory.create(pathFactory.create(simpleTypeFieldRootPath,
416 JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE),
417 pathFactory.createSegment(JavaMetadataLexicon.VARIABLE,
418 simpleTypeVariableIndex));
419 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, variablePath);
420 simpleTypeVariableIndex++;
421 }
422
423 simpleIndex++;
424 }
425
426 // Qualified type
427 if (fieldMetadata instanceof QualifiedTypeFieldMetadata) {
428 @SuppressWarnings( "unused" )
429 QualifiedTypeFieldMetadata qualifiedTypeFieldMetadata = (QualifiedTypeFieldMetadata)fieldMetadata;
430 }
431
432 // Parameterized type
433 if (fieldMetadata instanceof ParameterizedTypeFieldMetadata) {
434 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)fieldMetadata;
435 Path parameterizedTypeFieldRootPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRootPath(pathFactory,
436 parameterizedIndex);
437 ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeName(parameterizedTypeFieldMetadata,
438 parameterizedTypeFieldRootPath,
439 pathFactory,
440 nameFactory,
441 output);
442
443 // Parameterized type modifiers
444 List<ModifierMetadata> parameterizedTypeModifiers = parameterizedTypeFieldMetadata.getModifiers();
445 int parameterizedTypeModifierIndex = 1;
446 for (ModifierMetadata modifierMetadata : parameterizedTypeModifiers) {
447 Path parameterizedTypeModifierPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRModifierPath(pathFactory,
448 parameterizedTypeFieldRootPath,
449 parameterizedTypeModifierIndex);
450 ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeModifier(modifierMetadata,
451 parameterizedTypeModifierPath,
452 pathFactory,
453 nameFactory,
454 output);
455 parameterizedTypeModifierIndex++;
456 }
457 // Parameterized type variables
458 List<Variable> parameterizedTypeVariables = parameterizedTypeFieldMetadata.getVariables();
459 int parameterizedTypeVariableIndex = 1;
460 for (Variable variable : parameterizedTypeVariables) {
461
462 Path parameterizedTypeVariableChildNode = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldVariablePath(pathFactory,
463 parameterizedTypeFieldRootPath,
464 parameterizedTypeVariableIndex);
465 VariableSequencer.sequenceTheVariable(output,
466 nameFactory,
467 variable,
468 parameterizedTypeVariableChildNode);
469 parameterizedTypeVariableIndex++;
470 }
471
472 parameterizedIndex++;
473 }
474
475 }
476
477 // process methods of the unit.
478 List<MethodMetadata> methods = classMetadata.getMethods();
479 int methodIndex = 1;
480 int constructorIndex = 1;
481 for (MethodMetadata methodMetadata : methods) {
482 if (methodMetadata.isContructor()) {
483 // process constructor
484 ConstructorMetadata constructorMetadata = (ConstructorMetadata)methodMetadata;
485 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
486 JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE,
487 JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE,
488 JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE,
489 JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE,
490 JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE);
491 Path constructorRootPath = pathFactory.create(basePath,
492 pathFactory.createSegment(JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE,
493 constructorIndex));
494 output.setProperty(constructorRootPath,
495 JavaMetadataLexicon.CONSTRUCTOR_NAME,
496 constructorMetadata.getName());
497 List<ModifierMetadata> modifiers = constructorMetadata.getModifiers();
498 // modifiers
499 int constructorModifierIndex = 1;
500 for (ModifierMetadata modifierMetadata : modifiers) {
501 Path contructorModifierPath = pathFactory.create(pathFactory.create(constructorRootPath,
502 JavaMetadataLexicon.MODIFIER_CHILD_NODE),
503 pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE,
504 constructorModifierIndex));
505
506 output.setProperty(contructorModifierPath,
507 JavaMetadataLexicon.MODIFIER_NAME,
508 modifierMetadata.getName());
509 constructorModifierIndex++;
510 }
511
512 // constructor parameters
513 int constructorParameterIndex = 1;
514 for (FieldMetadata fieldMetadata : constructorMetadata.getParameters()) {
515
516 Path constructorParameterRootPath = pathFactory.create(pathFactory.create(constructorRootPath,
517 JavaMetadataLexicon.PARAMETER),
518 pathFactory.createSegment(JavaMetadataLexicon.FORMAL_PARAMETER,
519 constructorParameterIndex));
520 // primitive type
521 if (fieldMetadata instanceof PrimitiveFieldMetadata) {
522
523 PrimitiveFieldMetadata primitiveMetadata = (PrimitiveFieldMetadata)fieldMetadata;
524 Path constructPrimitiveFormalParamRootPath = MethodMetadataSequencer.createMethodParamRootPath(pathFactory,
525 constructorParameterRootPath);
526 // type
527 output.setProperty(constructPrimitiveFormalParamRootPath,
528 JavaMetadataLexicon.PRIMITIVE_TYPE_NAME,
529 primitiveMetadata.getType());
530
531 Path constructorPrimitiveParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory,
532 constructPrimitiveFormalParamRootPath);
533 // variables
534 for (Variable variable : primitiveMetadata.getVariables()) {
535 VariableSequencer.sequenceTheVariable(output,
536 nameFactory,
537 variable,
538 constructorPrimitiveParamChildNode);
539 }
540 }
541 // Simple type
542 if (fieldMetadata instanceof SimpleTypeFieldMetadata) {
543 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata;
544 SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output,
545 nameFactory,
546 pathFactory,
547 simpleTypeFieldMetadata,
548 constructorParameterRootPath);
549
550 }
551 // parameterized type
552 if (fieldMetadata instanceof ParameterizedTypeFieldMetadata) {
553 @SuppressWarnings( "unused" )
554 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)fieldMetadata;
555
556 }
557 // TODO support for more types
558
559 constructorParameterIndex++;
560 }
561
562 constructorIndex++;
563 } else {
564 // normal method
565 MethodTypeMemberMetadata methodTypeMemberMetadata = (MethodTypeMemberMetadata)methodMetadata;
566 Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE,
567 JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE,
568 JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE,
569 JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE,
570 JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE,
571 JavaMetadataLexicon.METHOD_CHILD_NODE);
572
573 Path methodRootPath = pathFactory.create(basePath,
574 pathFactory.createSegment(JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE,
575 methodIndex));
576
577 output.setProperty(methodRootPath,
578 JavaMetadataLexicon.METHOD_NAME,
579 methodTypeMemberMetadata.getName());
580
581 // method modifiers
582 int methodModierIndex = 1;
583 for (ModifierMetadata modifierMetadata : methodTypeMemberMetadata.getModifiers()) {
584 Path methodModifierPath = pathFactory.create(pathFactory.create(methodRootPath,
585 JavaMetadataLexicon.MODIFIER_CHILD_NODE),
586 pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE,
587 methodModierIndex));
588 output.setProperty(methodModifierPath,
589 JavaMetadataLexicon.MODIFIER_NAME,
590 modifierMetadata.getName());
591 methodModierIndex++;
592 }
593
594 int methodParameterIndex = 1;
595 for (FieldMetadata fieldMetadata : methodMetadata.getParameters()) {
596
597 Path methodParamRootPath = pathFactory.create(pathFactory.create(methodRootPath,
598 JavaMetadataLexicon.PARAMETER),
599 pathFactory.createSegment(JavaMetadataLexicon.FORMAL_PARAMETER,
600 methodParameterIndex));
601
602 if (fieldMetadata instanceof PrimitiveFieldMetadata) {
603
604 PrimitiveFieldMetadata primitive = (PrimitiveFieldMetadata)fieldMetadata;
605
606 Path methodPrimitiveFormalParamRootPath = pathFactory.create(methodParamRootPath,
607 JavaMetadataLexicon.TYPE_CHILD_NODE,
608 JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE);
609
610 Path methodParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory,
611 methodPrimitiveFormalParamRootPath);
612 // variables
613 for (Variable variable : primitive.getVariables()) {
614 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, methodParamChildNode);
615 }
616 // type
617 Path methodPrimitiveTypeParamChildNode = pathFactory.create(methodPrimitiveFormalParamRootPath);
618 output.setProperty(methodPrimitiveTypeParamChildNode,
619 JavaMetadataLexicon.PRIMITIVE_TYPE_NAME,
620 primitive.getType());
621
622 }
623
624 if (fieldMetadata instanceof SimpleTypeFieldMetadata) {
625 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata;
626 SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output,
627 nameFactory,
628 pathFactory,
629 simpleTypeFieldMetadata,
630 methodParamRootPath);
631 }
632 if (fieldMetadata instanceof ArrayTypeFieldMetadata) {
633 ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata;
634
635 ArrayTypeFieldMetadataSequencer.sequenceMethodFormalParam(output,
636 nameFactory,
637 pathFactory,
638 arrayTypeFieldMetadata,
639 methodParamRootPath);
640
641 }
642
643 // TODO parameter reference types
644
645 methodParameterIndex++;
646 }
647
648 // method return type
649 FieldMetadata methodReturnType = methodTypeMemberMetadata.getReturnType();
650
651 if (methodReturnType instanceof PrimitiveFieldMetadata) {
652 PrimitiveFieldMetadata methodReturnPrimitiveType = (PrimitiveFieldMetadata)methodReturnType;
653 Path methodReturnPrimitiveTypePath = pathFactory.create(pathFactory.create(methodRootPath,
654 JavaMetadataLexicon.RETURN_TYPE),
655 JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE);
656 Path methodReturnPrimitiveTypeChildNode = pathFactory.create(methodReturnPrimitiveTypePath);
657 output.setProperty(methodReturnPrimitiveTypeChildNode,
658 JavaMetadataLexicon.PRIMITIVE_TYPE_NAME,
659 methodReturnPrimitiveType.getType());
660
661 }
662 if (methodReturnType instanceof SimpleTypeFieldMetadata) {
663 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)methodReturnType;
664 SimpleTypeMetadataSequencer.sequenceMethodReturnType(output,
665 nameFactory,
666 pathFactory,
667 simpleTypeFieldMetadata,
668 methodRootPath);
669 }
670
671 // TODO method return reference type
672
673 methodIndex++;
674 }
675 }
676 }
677 // interface declaration
678
679 // enumeration declaration
680 }
681 }
682
683 }
684
685 }