001 /* 002 * JBoss, Home of Professional Open Source. 003 * Copyright 2008, Red Hat Middleware LLC, and individual contributors 004 * as indicated by the @author tags. See the copyright.txt file in the 005 * distribution for a full listing of individual contributors. 006 * 007 * This is free software; you can redistribute it and/or modify it 008 * under the terms of the GNU Lesser General Public License as 009 * published by the Free Software Foundation; either version 2.1 of 010 * the License, or (at your option) any later version. 011 * 012 * This software is distributed in the hope that it will be useful, 013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 015 * Lesser General Public License for more details. 016 * 017 * You should have received a copy of the GNU Lesser General Public 018 * License along with this software; if not, write to the Free 019 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 020 * 02110-1301 USA, or see the FSF site: http://www.fsf.org. 021 */ 022 package org.jboss.dna.sequencer.java; 023 024 import java.io.IOException; 025 import java.io.InputStream; 026 import java.util.List; 027 import org.apache.commons.lang.StringUtils; 028 import org.jboss.dna.graph.properties.NameFactory; 029 import org.jboss.dna.graph.properties.Path; 030 import org.jboss.dna.graph.properties.PathFactory; 031 import org.jboss.dna.graph.sequencers.SequencerContext; 032 import org.jboss.dna.graph.sequencers.SequencerOutput; 033 import org.jboss.dna.graph.sequencers.StreamSequencer; 034 import org.jboss.dna.sequencer.java.metadata.AnnotationMetadata; 035 import org.jboss.dna.sequencer.java.metadata.ArrayTypeFieldMetadata; 036 import org.jboss.dna.sequencer.java.metadata.ClassMetadata; 037 import org.jboss.dna.sequencer.java.metadata.ConstructorMetadata; 038 import org.jboss.dna.sequencer.java.metadata.FieldMetadata; 039 import org.jboss.dna.sequencer.java.metadata.ImportMetadata; 040 import org.jboss.dna.sequencer.java.metadata.ImportOnDemandMetadata; 041 import org.jboss.dna.sequencer.java.metadata.JavaMetadata; 042 import org.jboss.dna.sequencer.java.metadata.MarkerAnnotationMetadata; 043 import org.jboss.dna.sequencer.java.metadata.MethodMetadata; 044 import org.jboss.dna.sequencer.java.metadata.MethodTypeMemberMetadata; 045 import org.jboss.dna.sequencer.java.metadata.ModifierMetadata; 046 import org.jboss.dna.sequencer.java.metadata.NormalAnnotationMetadata; 047 import org.jboss.dna.sequencer.java.metadata.PackageMetadata; 048 import org.jboss.dna.sequencer.java.metadata.ParameterizedTypeFieldMetadata; 049 import org.jboss.dna.sequencer.java.metadata.PrimitiveFieldMetadata; 050 import org.jboss.dna.sequencer.java.metadata.QualifiedTypeFieldMetadata; 051 import org.jboss.dna.sequencer.java.metadata.SimpleTypeFieldMetadata; 052 import org.jboss.dna.sequencer.java.metadata.SingleImportMetadata; 053 import org.jboss.dna.sequencer.java.metadata.SingleMemberAnnotationMetadata; 054 import org.jboss.dna.sequencer.java.metadata.TypeMetadata; 055 import org.jboss.dna.sequencer.java.metadata.Variable; 056 057 /** 058 * A Java sequencer that processes a compilation unit, extracts the meta data for the compilation unit, and then writes these 059 * informations to the repository. 060 * <p> 061 * The structural representation of the informations from the compilation unit looks like this: 062 * <ul> 063 * <li><strong>java:compilationUnit</strong> node of type <code>java:compilationUnit</code> 064 * <ul> 065 * <li> <strong>java:package</strong> - optional child node that represents the package child node of the compilation unit. 066 * <ul> 067 * <li> <strong>java:packageDeclaration</strong> - the package declaration. 068 * <ul> 069 * <li><strong>java:packageName</strong></li> - the package name. 070 * </ul> 071 * </li> 072 * </ul> 073 * </li> 074 * <li> <strong>java:import</strong> - optional child node that represents the import declaration of the compilation unit 075 * <ul> 076 * <li> <strong>java:importDeclaration</strong> - the import declaration 077 * <ul> 078 * <li><strong>java:singleImport</strong> 079 * <ul> 080 * <li> <strong>java:singleTypeImportDeclaration</strong> 081 * <ul> 082 * <li> <strong>java:singleTypeImportkeyword</strong> - the keyword "import" 083 * <li><strong>java:singleImportName</strong></li> - the name of a single import. </li> 084 * </ul> 085 * </li> 086 * </ul> 087 * </li> 088 * <li><strong>java:importOnDemand</strong> 089 * <li> <strong>java:typeImportOnDemandDeclaration</strong> 090 * <ul> 091 * <li> <strong>java:onDemandImportKeyword</strong> - the keyword "import" 092 * <li><strong>java:onDemandImportName</strong></li> - the name of the on demand import. </li> 093 * </ul> 094 * </li> 095 * </li> 096 * </ul> 097 * </li> 098 * </ul> 099 * </li> 100 * <li><strong>java:unitType</strong> - optional child node that represents the top level type (class, interface, enum, 101 * annotation) declaration of the compilation unit</li> 102 * <ul> 103 * <li> <strong>java:classDeclaration</strong> - optional child node that represents the class declaration of the compilation 104 * unit 105 * <ul> 106 * <li> <strong>java:normalClass</strong> - the normal class. 107 * <ul> 108 * <li> <strong>java:normalClassDeclaration</strong> - the normal class declaration 109 * <ul> 110 * <li> <strong>java:modifier</strong> - modifier child node. 111 * <ul> 112 * <li><strong>java:modifierDeclaration</strong> - the modifier declaration. 113 * <ul> 114 * <li><strong>java:modifierName</strong> - modifier name.</li> 115 * </ul> 116 * </li> 117 * </ul> 118 * </li> 119 * <li> <strong>java:normalClassName</strong> - class name.</li> 120 * <li> <strong>java:field</strong> - field child node. 121 * <ul> 122 * <li><strong>java:fieldType</strong> - field type child node. 123 * <ul> 124 * <li><strong>java:type</strong> - type child node. 125 * <ul> 126 * <li>[java:primitiveType, java:simpleType, java:parameterizedType] - can be primitive type or simple type and or parameterized 127 * type<.</li> 128 * </ul> 129 * </li> 130 * </ul> 131 * </li> 132 * </ul> 133 * </li> 134 * <li> <strong>java:constructor</strong> - the constructor child node 135 * <ul> 136 * <li><strong>java:constructorDeclaration</strong> - the constructor declaration. 137 * <ul> 138 * <li><strong>java:constructorName</strong> - constructor name. </li> 139 * <li><strong>java:modifier </strong> - the modifier child node.</li> + 140 * <li><strong>java:parameter </strong> - the parameter child node</li> 141 * </ul> 142 * </li> 143 * </ul> 144 * </li> 145 * <li> <strong>java:method</strong> - method child node. 146 * <ul> 147 * <li></strong>java:methodDeclaration</strong> - method declaration. 148 * <ul> 149 * <li><strong>java:methodName </strong> - method name. </li> 150 * <li><strong>java:modifier </strong> - the modifier child node.</li> + 151 * <li><strong>java:resultType </strong> - the result type child node </li> + 152 * <li><strong>java:parameter </strong> - the parameter child node</li> 153 * </ul> 154 * </li> 155 * </ul> 156 * </li> 157 * </ul> 158 * </li> 159 * </ul> 160 * </li> 161 * </ul> 162 * </li> 163 * </ul> 164 * </li> 165 * </ul> 166 * </p> 167 * 168 * @author Serge Pagop 169 * @author John Verhaeg 170 */ 171 public class JavaMetadataSequencer implements JavaSourceCndDefinition, StreamSequencer { 172 173 /** 174 * {@inheritDoc} 175 * 176 * @see org.jboss.dna.graph.sequencers.StreamSequencer#sequence(java.io.InputStream, 177 * org.jboss.dna.graph.sequencers.SequencerOutput, org.jboss.dna.graph.sequencers.SequencerContext) 178 */ 179 public void sequence( InputStream stream, 180 SequencerOutput output, 181 SequencerContext context ) { 182 JavaMetadata javaMetadata = null; 183 NameFactory nameFactory = context.getValueFactories().getNameFactory(); 184 PathFactory pathFactory = context.getValueFactories().getPathFactory(); 185 186 try { 187 javaMetadata = JavaMetadata.instance(stream, JavaMetadataUtil.length(stream), null); 188 } catch (IOException e) { 189 e.printStackTrace(); 190 return; 191 } 192 if (javaMetadata != null) { 193 Path javaCompilationUnitNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE); 194 output.setProperty(javaCompilationUnitNode, 195 nameFactory.create(JAVA_COMPILATION_UNIT_PRIMARY_TYPE), 196 "java:compilationUnit"); 197 198 // sequence package declaration of a unit. 199 PackageMetadata packageMetadata = javaMetadata.getPackageMetadata(); 200 if (packageMetadata != null) { 201 if (StringUtils.isNotEmpty(packageMetadata.getName())) { 202 203 Path javaPackageDeclarationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH 204 + JAVA_PACKAGE_CHILD_NODE + SLASH 205 + JAVA_PACKAGE_DECLARATION_CHILD_NODE); 206 output.setProperty(javaPackageDeclarationChildNode, 207 nameFactory.create(JAVA_PACKAGE_NAME), 208 javaMetadata.getPackageMetadata().getName()); 209 } 210 211 int markerAnnotationIndex = 1; 212 int singleAnnatationIndex = 1; 213 int normalAnnotationIndex = 1; 214 for (AnnotationMetadata annotationMetadata : packageMetadata.getAnnotationMetada()) { 215 if (annotationMetadata instanceof MarkerAnnotationMetadata) { 216 MarkerAnnotationMetadata markerAnnotationMetadata = (MarkerAnnotationMetadata)annotationMetadata; 217 Path markerAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH 218 + JAVA_PACKAGE_CHILD_NODE + SLASH 219 + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH 220 + JAVA_ANNOTATION_CHILD_NODE + SLASH 221 + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH 222 + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH 223 + JAVA_MARKER_ANNOTATION_CHILD_NODE + "[" 224 + markerAnnotationIndex + "]"); 225 output.setProperty(markerAnnotationChildNode, 226 nameFactory.create(JAVA_MARKER_ANNOTATION_NAME), 227 markerAnnotationMetadata.getName()); 228 markerAnnotationIndex++; 229 } 230 if (annotationMetadata instanceof SingleMemberAnnotationMetadata) { 231 SingleMemberAnnotationMetadata singleMemberAnnotationMetadata = (SingleMemberAnnotationMetadata)annotationMetadata; 232 Path singleMemberAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH 233 + JAVA_PACKAGE_CHILD_NODE + SLASH 234 + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH 235 + JAVA_ANNOTATION_CHILD_NODE + SLASH 236 + JAVA_ANNOTATION_DECLARATION_CHILD_NODE 237 + SLASH + JAVA_ANNOTATION_TYPE_CHILD_NODE 238 + SLASH 239 + JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE 240 + "[" + singleAnnatationIndex + "]"); 241 output.setProperty(singleMemberAnnotationChildNode, 242 nameFactory.create(JAVA_SINGLE_ANNOTATION_NAME), 243 singleMemberAnnotationMetadata.getName()); 244 singleAnnatationIndex++; 245 } 246 if (annotationMetadata instanceof NormalAnnotationMetadata) { 247 NormalAnnotationMetadata normalAnnotationMetadata = (NormalAnnotationMetadata)annotationMetadata; 248 Path normalAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH 249 + JAVA_PACKAGE_CHILD_NODE + SLASH 250 + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH 251 + JAVA_ANNOTATION_CHILD_NODE + SLASH 252 + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH 253 + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH 254 + JAVA_NORMAL_ANNOTATION_CHILD_NODE + "[" 255 + normalAnnotationIndex + "]"); 256 257 output.setProperty(normalAnnotationChildNode, 258 nameFactory.create(JAVA_NORMALANNOTATION_NAME), 259 normalAnnotationMetadata.getName()); 260 normalAnnotationIndex++; 261 } 262 } 263 } 264 265 // sequence import declarations of a unit 266 int importOnDemandIndex = 1; 267 int singleImportIndex = 1; 268 for (ImportMetadata importMetadata : javaMetadata.getImports()) { 269 if (importMetadata instanceof ImportOnDemandMetadata) { 270 ImportOnDemandMetadata importOnDemandMetadata = (ImportOnDemandMetadata)importMetadata; 271 Path importOnDemandChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_IMPORT_CHILD_NODE 272 + SLASH + JAVA_IMPORT_DECLARATION_CHILD_NODE + SLASH 273 + JAVA_ON_DEMAND_IMPORT_CHILD_NODE + SLASH 274 + JAVA_ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE + "[" 275 + importOnDemandIndex + "]"); 276 output.setProperty(importOnDemandChildNode, 277 nameFactory.create(JAVA_ON_DEMAND_IMPORT_NAME), 278 importOnDemandMetadata.getName()); 279 importOnDemandIndex++; 280 } 281 if (importMetadata instanceof SingleImportMetadata) { 282 SingleImportMetadata singleImportMetadata = (SingleImportMetadata)importMetadata; 283 Path singleImportChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_IMPORT_CHILD_NODE 284 + SLASH + JAVA_IMPORT_DECLARATION_CHILD_NODE + SLASH 285 + JAVA_SINGLE_IMPORT_CHILD_NODE + SLASH 286 + JAVA_SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE + "[" 287 + singleImportIndex + "]"); 288 output.setProperty(singleImportChildNode, 289 nameFactory.create(JAVA_SINGLE_IMPORT_NAME), 290 singleImportMetadata.getName()); 291 singleImportIndex++; 292 } 293 } 294 295 // sequence type declaration (class declaration) information 296 for (TypeMetadata typeMetadata : javaMetadata.getTypeMetadata()) { 297 // class declaration 298 if (typeMetadata instanceof ClassMetadata) { 299 300 String normalClassRootPath = JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_UNIT_TYPE_CHILD_NODE + SLASH 301 + JAVA_CLASS_DECLARATION_CHILD_NODE + SLASH + JAVA_NORMAL_CLASS_CHILD_NODE 302 + SLASH + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE; 303 304 ClassMetadata classMetadata = (ClassMetadata)typeMetadata; 305 Path classChildNode = pathFactory.create(normalClassRootPath); 306 output.setProperty(classChildNode, nameFactory.create(JAVA_NORMAL_CLASS_NAME), classMetadata.getName()); 307 308 // process modifiers of the class declaration 309 List<ModifierMetadata> classModifiers = classMetadata.getModifiers(); 310 int modifierIndex = 1; 311 for (ModifierMetadata modifierMetadata : classModifiers) { 312 313 Path classModifierChildNode = pathFactory.create(normalClassRootPath + SLASH + JAVA_MODIFIER_CHILD_NODE 314 + SLASH + JAVA_MODIFIER_DECLARATION_CHILD_NODE + "[" 315 + modifierIndex + "]"); 316 317 output.setProperty(classModifierChildNode, 318 nameFactory.create(JAVA_MODIFIER_NAME), 319 modifierMetadata.getName()); 320 } 321 322 // process fields of the class unit. 323 int primitiveIndex = 1; 324 int simpleIndex = 1; 325 int parameterizedIndex = 1; 326 int arrayIndex = 1; 327 for (FieldMetadata fieldMetadata : classMetadata.getFields()) { 328 String fieldMemberDataRootPath = JavaMetadataUtil.createPath(normalClassRootPath + SLASH 329 + JAVA_FIELD_CHILD_NODE + SLASH 330 + JAVA_FIELD_TYPE_CHILD_NODE + SLASH 331 + JAVA_TYPE_CHILD_NODE); 332 if (fieldMetadata instanceof PrimitiveFieldMetadata) { 333 // primitive type 334 PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fieldMetadata; 335 String primitiveFieldRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH 336 + JAVA_PRIMITIVE_TYPE_CHILD_NODE, 337 primitiveIndex); 338 // type 339 Path primitiveTypeChildNode = pathFactory.create(primitiveFieldRootPath); 340 output.setProperty(primitiveTypeChildNode, 341 nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), 342 primitiveFieldMetadata.getType()); 343 // modifiers 344 List<ModifierMetadata> modifiers = primitiveFieldMetadata.getModifiers(); 345 int primitiveModifierIndex = 1; 346 for (ModifierMetadata modifierMetadata : modifiers) { 347 String modifierPath = JavaMetadataUtil.createPathWithIndex(primitiveFieldRootPath + SLASH 348 + JAVA_MODIFIER_CHILD_NODE + SLASH 349 + JAVA_MODIFIER_DECLARATION_CHILD_NODE, 350 primitiveModifierIndex); 351 Path modifierChildNode = pathFactory.create(modifierPath); 352 output.setProperty(modifierChildNode, 353 nameFactory.create(JAVA_MODIFIER_NAME), 354 modifierMetadata.getName()); 355 primitiveModifierIndex++; 356 } 357 // variables 358 List<Variable> variables = primitiveFieldMetadata.getVariables(); 359 int primitiveVariableIndex = 1; 360 for (Variable variable : variables) { 361 String variablePath = JavaMetadataUtil.createPathWithIndex(primitiveFieldRootPath + SLASH 362 + JAVA_PRIMITIVE_TYPE_VARIABLE + SLASH 363 + JAVA_VARIABLE, 364 primitiveVariableIndex); 365 Path primitiveChildNode = pathFactory.create(variablePath); 366 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); 367 primitiveVariableIndex++; 368 } 369 primitiveIndex++; 370 } 371 372 // Array type 373 if (fieldMetadata instanceof ArrayTypeFieldMetadata) { 374 ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; 375 String arrayTypeRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH 376 + JAVA_ARRAY_TYPE_CHILD_NODE, 377 arrayIndex); 378 ArrayTypeFieldMetadataSequencer.sequenceFieldMemberData(arrayTypeFieldMetadata, 379 pathFactory, 380 nameFactory, 381 output, 382 arrayTypeRootPath, 383 arrayIndex); 384 arrayIndex++; 385 } 386 387 // Simple type 388 if (fieldMetadata instanceof SimpleTypeFieldMetadata) { 389 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; 390 String simpleTypeFieldRootPath = JavaMetadataUtil.createPathWithIndex(JAVA_COMPILATION_UNIT_NODE 391 + SLASH 392 + JAVA_UNIT_TYPE_CHILD_NODE 393 + SLASH 394 + JAVA_CLASS_DECLARATION_CHILD_NODE 395 + SLASH 396 + JAVA_NORMAL_CLASS_CHILD_NODE 397 + SLASH 398 + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE 399 + SLASH + JAVA_FIELD_CHILD_NODE 400 + SLASH 401 + JAVA_FIELD_TYPE_CHILD_NODE 402 + SLASH + JAVA_TYPE_CHILD_NODE 403 + SLASH 404 + JAVA_SIMPLE_TYPE_CHILD_NODE, 405 simpleIndex); 406 Path simpleTypeFieldChildNode = pathFactory.create(simpleTypeFieldRootPath); 407 output.setProperty(simpleTypeFieldChildNode, 408 nameFactory.create(JAVA_SIMPLE_TYPE_NAME), 409 simpleTypeFieldMetadata.getType()); 410 411 // Simple type modifies 412 List<ModifierMetadata> simpleModifiers = simpleTypeFieldMetadata.getModifiers(); 413 int simpleTypeModifierIndex = 1; 414 for (ModifierMetadata modifierMetadata : simpleModifiers) { 415 String simpleTypeModifierPath = JavaMetadataUtil.createPathWithIndex(simpleTypeFieldRootPath 416 + SLASH 417 + JAVA_SIMPLE_TYPE_MODIFIER_CHILD_NODE 418 + SLASH 419 + JAVA_MODIFIER_DECLARATION_CHILD_NODE, 420 simpleTypeModifierIndex); 421 Path simpleTypeModifierChildNode = pathFactory.create(simpleTypeModifierPath); 422 output.setProperty(simpleTypeModifierChildNode, 423 nameFactory.create(JAVA_MODIFIER_NAME), 424 modifierMetadata.getName()); 425 simpleTypeModifierIndex++; 426 } 427 428 // Simple type variables 429 List<Variable> variables = simpleTypeFieldMetadata.getVariables(); 430 int simpleTypeVariableIndex = 1; 431 for (Variable variable : variables) { 432 String variablePath = JavaMetadataUtil.createPathWithIndex(simpleTypeFieldRootPath + SLASH 433 + JAVA_SIMPLE_TYPE_VARIABLE + SLASH 434 + JAVA_VARIABLE, 435 simpleTypeVariableIndex); 436 Path primitiveChildNode = pathFactory.create(variablePath); 437 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); 438 simpleTypeVariableIndex++; 439 } 440 441 simpleIndex++; 442 } 443 444 // Qualified type 445 if (fieldMetadata instanceof QualifiedTypeFieldMetadata) { 446 @SuppressWarnings( "unused" ) 447 QualifiedTypeFieldMetadata qualifiedTypeFieldMetadata = (QualifiedTypeFieldMetadata)fieldMetadata; 448 } 449 450 // Parameterized type 451 if (fieldMetadata instanceof ParameterizedTypeFieldMetadata) { 452 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)fieldMetadata; 453 String parameterizedTypeFieldRootPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRootPath(parameterizedIndex); 454 ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeName(parameterizedTypeFieldMetadata, 455 parameterizedTypeFieldRootPath, 456 pathFactory, 457 nameFactory, 458 output); 459 // Parameterized type modifiers 460 List<ModifierMetadata> parameterizedTypeModifiers = parameterizedTypeFieldMetadata.getModifiers(); 461 int parameterizedTypeModifierIndex = 1; 462 for (ModifierMetadata modifierMetadata : parameterizedTypeModifiers) { 463 String parameterizedTypeModifierPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRModifierPath(parameterizedTypeFieldRootPath, 464 parameterizedTypeModifierIndex); 465 ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeModifier(modifierMetadata, 466 parameterizedTypeModifierPath, 467 pathFactory, 468 nameFactory, 469 output); 470 parameterizedTypeModifierIndex++; 471 } 472 // Parameterized type variables 473 List<Variable> parameterizedTypeVariables = parameterizedTypeFieldMetadata.getVariables(); 474 int parameterizedTypeVariableIndex = 1; 475 for (Variable variable : parameterizedTypeVariables) { 476 477 Path parameterizedTypeVariableChildNode = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldVariablePath(pathFactory, 478 parameterizedTypeFieldRootPath, 479 parameterizedTypeVariableIndex); 480 VariableSequencer.sequenceTheVariable(output, 481 nameFactory, 482 variable, 483 parameterizedTypeVariableChildNode); 484 parameterizedTypeVariableIndex++; 485 } 486 487 parameterizedIndex++; 488 } 489 490 } 491 492 // process methods of the unit. 493 List<MethodMetadata> methods = classMetadata.getMethods(); 494 int methodIndex = 1; 495 int constructorIndex = 1; 496 for (MethodMetadata methodMetadata : methods) { 497 if (methodMetadata.isContructor()) { 498 // process constructor 499 ConstructorMetadata constructorMetadata = (ConstructorMetadata)methodMetadata; 500 String constructorRootPath = JavaMetadataUtil.createPathWithIndex(JAVA_COMPILATION_UNIT_NODE 501 + SLASH 502 + JAVA_UNIT_TYPE_CHILD_NODE 503 + SLASH 504 + JAVA_CLASS_DECLARATION_CHILD_NODE 505 + SLASH 506 + JAVA_NORMAL_CLASS_CHILD_NODE 507 + SLASH 508 + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE 509 + SLASH 510 + JAVA_CONSTRUCTOR_CHILD_NODE 511 + SLASH 512 + JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE, 513 constructorIndex); 514 Path constructorChildNode = pathFactory.create(constructorRootPath); 515 output.setProperty(constructorChildNode, 516 nameFactory.create(JAVA_CONSTRUCTOR_NAME), 517 constructorMetadata.getName()); 518 List<ModifierMetadata> modifiers = constructorMetadata.getModifiers(); 519 // modifiers 520 int constructorModifierIndex = 1; 521 for (ModifierMetadata modifierMetadata : modifiers) { 522 String contructorModifierPath = JavaMetadataUtil.createPathWithIndex(constructorRootPath 523 + SLASH 524 + JAVA_MODIFIER_CHILD_NODE 525 + SLASH 526 + JAVA_MODIFIER_DECLARATION_CHILD_NODE, 527 constructorModifierIndex); 528 529 Path constructorModifierChildNode = pathFactory.create(contructorModifierPath); 530 output.setProperty(constructorModifierChildNode, 531 nameFactory.create(JAVA_MODIFIER_NAME), 532 modifierMetadata.getName()); 533 constructorModifierIndex++; 534 } 535 536 // constructor parameters 537 int constructorParameterIndex = 1; 538 for (FieldMetadata fieldMetadata : constructorMetadata.getParameters()) { 539 540 String constructorParameterRootPath = JavaMetadataUtil.createPathWithIndex(constructorRootPath 541 + SLASH 542 + JAVA_PARAMETER 543 + SLASH 544 + JAVA_FORMAL_PARAMETER, 545 constructorParameterIndex); 546 // primitive type 547 if (fieldMetadata instanceof PrimitiveFieldMetadata) { 548 549 PrimitiveFieldMetadata primitiveMetadata = (PrimitiveFieldMetadata)fieldMetadata; 550 String constructPrimitiveFormalParamRootPath = MethodMetadataSequencer.createMethodParamRootPath(constructorParameterRootPath); 551 // type 552 Path constructorPrimitiveTypeParamChildNode = pathFactory.create(constructPrimitiveFormalParamRootPath); 553 output.setProperty(constructorPrimitiveTypeParamChildNode, 554 nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), 555 primitiveMetadata.getType()); 556 557 Path constructorPrimitiveParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory, 558 constructPrimitiveFormalParamRootPath); 559 // variables 560 for (Variable variable : primitiveMetadata.getVariables()) { 561 VariableSequencer.sequenceTheVariable(output, 562 nameFactory, 563 variable, 564 constructorPrimitiveParamChildNode); 565 } 566 } 567 // Simple type 568 if (fieldMetadata instanceof SimpleTypeFieldMetadata) { 569 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; 570 SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output, 571 nameFactory, 572 pathFactory, 573 simpleTypeFieldMetadata, 574 constructorParameterRootPath); 575 576 } 577 // parameterized type 578 if (fieldMetadata instanceof ParameterizedTypeFieldMetadata) { 579 @SuppressWarnings( "unused" ) 580 ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)fieldMetadata; 581 582 } 583 // TODO support for more types 584 585 constructorParameterIndex++; 586 } 587 588 constructorIndex++; 589 } else { 590 591 // normal method 592 MethodTypeMemberMetadata methodTypeMemberMetadata = (MethodTypeMemberMetadata)methodMetadata; 593 String methodRootPath = JavaMetadataUtil.createPathWithIndex(JAVA_COMPILATION_UNIT_NODE 594 + SLASH 595 + JAVA_UNIT_TYPE_CHILD_NODE 596 + SLASH 597 + JAVA_CLASS_DECLARATION_CHILD_NODE 598 + SLASH 599 + JAVA_NORMAL_CLASS_CHILD_NODE 600 + SLASH 601 + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE 602 + SLASH + JAVA_METHOD_CHILD_NODE + SLASH 603 + JAVA_METHOD_DECLARATION_CHILD_NODE, 604 methodIndex); 605 Path methodChildNode = pathFactory.create(methodRootPath); 606 output.setProperty(methodChildNode, 607 nameFactory.create(JAVA_METHOD_NAME), 608 methodTypeMemberMetadata.getName()); 609 610 // method modifiers 611 int methodModierIndex = 1; 612 for (ModifierMetadata modifierMetadata : methodTypeMemberMetadata.getModifiers()) { 613 String methodModifierPath = JavaMetadataUtil.createPathWithIndex(methodRootPath 614 + SLASH 615 + JAVA_MODIFIER_CHILD_NODE 616 + SLASH 617 + JAVA_MODIFIER_DECLARATION_CHILD_NODE, 618 methodModierIndex); 619 Path methodModifierChildNode = pathFactory.create(methodModifierPath); 620 output.setProperty(methodModifierChildNode, 621 nameFactory.create(JAVA_MODIFIER_NAME), 622 modifierMetadata.getName()); 623 methodModierIndex++; 624 } 625 626 int methodParameterIndex = 1; 627 for (FieldMetadata fieldMetadata : methodMetadata.getParameters()) { 628 629 String methodParamRootPath = JavaMetadataUtil.createPathWithIndex(methodRootPath + SLASH 630 + JAVA_PARAMETER + SLASH 631 + JAVA_FORMAL_PARAMETER, 632 methodParameterIndex); 633 634 if (fieldMetadata instanceof PrimitiveFieldMetadata) { 635 636 PrimitiveFieldMetadata primitive = (PrimitiveFieldMetadata)fieldMetadata; 637 638 String methodPrimitiveFormalParamRootPath = JavaMetadataUtil.createPath(methodParamRootPath 639 + SLASH 640 + JAVA_TYPE_CHILD_NODE 641 + SLASH 642 + JAVA_PRIMITIVE_TYPE_CHILD_NODE); 643 644 Path methodParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory, 645 methodPrimitiveFormalParamRootPath); 646 // variables 647 for (Variable variable : primitive.getVariables()) { 648 VariableSequencer.sequenceTheVariable(output, nameFactory, variable, methodParamChildNode); 649 } 650 // type 651 Path methodPrimitiveTypeParamChildNode = pathFactory.create(methodPrimitiveFormalParamRootPath); 652 output.setProperty(methodPrimitiveTypeParamChildNode, 653 nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), 654 primitive.getType()); 655 656 } 657 658 if (fieldMetadata instanceof SimpleTypeFieldMetadata) { 659 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; 660 SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output, 661 nameFactory, 662 pathFactory, 663 simpleTypeFieldMetadata, 664 methodParamRootPath); 665 } 666 if (fieldMetadata instanceof ArrayTypeFieldMetadata) { 667 ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; 668 ArrayTypeFieldMetadataSequencer.sequenceMethodFormalParam(output, 669 nameFactory, 670 pathFactory, 671 arrayTypeFieldMetadata, 672 methodParamRootPath); 673 674 } 675 676 // TODO parameter reference types 677 678 methodParameterIndex++; 679 } 680 681 // method return type 682 FieldMetadata methodReturnType = methodTypeMemberMetadata.getReturnType(); 683 684 if (methodReturnType instanceof PrimitiveFieldMetadata) { 685 PrimitiveFieldMetadata methodReturnPrimitiveType = (PrimitiveFieldMetadata)methodReturnType; 686 String methodReturnPrimitiveTypePath = JavaMetadataUtil.createPath(methodRootPath 687 + SLASH 688 + JAVA_RETURN_TYPE 689 + SLASH 690 + JAVA_PRIMITIVE_TYPE_CHILD_NODE); 691 Path methodReturnPrimitiveTypeChildNode = pathFactory.create(methodReturnPrimitiveTypePath); 692 output.setProperty(methodReturnPrimitiveTypeChildNode, 693 nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), 694 methodReturnPrimitiveType.getType()); 695 696 } 697 if (methodReturnType instanceof SimpleTypeFieldMetadata) { 698 SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)methodReturnType; 699 SimpleTypeMetadataSequencer.sequenceMethodReturnType(output, 700 nameFactory, 701 pathFactory, 702 simpleTypeFieldMetadata, 703 methodRootPath); 704 } 705 706 // TODO method return reference type 707 708 methodIndex++; 709 } 710 } 711 } 712 // interface declaration 713 714 // enumeration declaration 715 } 716 } 717 } 718 }