001// =================== DO NOT EDIT THIS FILE ==================== 002// Generated by Modello 1.9.1, 003// any modifications will be overwritten. 004// ============================================================== 005 006package org.apache.maven.tools.plugin.extractor.model.io.xpp3; 007 008 //---------------------------------/ 009 //- Imported classes and packages -/ 010//---------------------------------/ 011 012import java.io.IOException; 013import java.io.InputStream; 014import java.io.Reader; 015import java.text.DateFormat; 016import org.apache.maven.tools.plugin.extractor.model.Component; 017import org.apache.maven.tools.plugin.extractor.model.LifecycleExecution; 018import org.apache.maven.tools.plugin.extractor.model.Mojo; 019import org.apache.maven.tools.plugin.extractor.model.Parameter; 020import org.apache.maven.tools.plugin.extractor.model.PluginMetadata; 021import org.codehaus.plexus.util.ReaderFactory; 022import org.codehaus.plexus.util.xml.pull.EntityReplacementMap; 023import org.codehaus.plexus.util.xml.pull.MXParser; 024import org.codehaus.plexus.util.xml.pull.XmlPullParser; 025import org.codehaus.plexus.util.xml.pull.XmlPullParserException; 026 027/** 028 * Class PluginMetadataXpp3Reader. 029 * 030 * @version $Revision$ $Date$ 031 */ 032@SuppressWarnings( "all" ) 033public class PluginMetadataXpp3Reader 034{ 035 036 //--------------------------/ 037 //- Class/Member Variables -/ 038 //--------------------------/ 039 040 /** 041 * If set the parser will be loaded with all single characters 042 * from the XHTML specification. 043 * The entities used: 044 * <ul> 045 * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li> 046 * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li> 047 * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li> 048 * </ul> 049 */ 050 private boolean addDefaultEntities = true; 051 052 /** 053 * Field contentTransformer. 054 */ 055 public final ContentTransformer contentTransformer; 056 057 058 //----------------/ 059 //- Constructors -/ 060 //----------------/ 061 062 public PluginMetadataXpp3Reader() 063 { 064 this( new ContentTransformer() 065 { 066 public String transform( String source, String fieldName ) 067 { 068 return source; 069 } 070 } ); 071 } //-- org.apache.maven.tools.plugin.extractor.model.io.xpp3.PluginMetadataXpp3Reader() 072 073 public PluginMetadataXpp3Reader(ContentTransformer contentTransformer) 074 { 075 this.contentTransformer = contentTransformer; 076 } //-- org.apache.maven.tools.plugin.extractor.model.io.xpp3.PluginMetadataXpp3Reader(ContentTransformer) 077 078 079 //-----------/ 080 //- Methods -/ 081 //-----------/ 082 083 /** 084 * Method checkFieldWithDuplicate. 085 * 086 * @param parser 087 * @param parsed 088 * @param alias 089 * @param tagName 090 * @throws XmlPullParserException 091 * @return boolean 092 */ 093 private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set parsed ) 094 throws XmlPullParserException 095 { 096 if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) ) 097 { 098 return false; 099 } 100 if ( !parsed.add( tagName ) ) 101 { 102 throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null ); 103 } 104 return true; 105 } //-- boolean checkFieldWithDuplicate( XmlPullParser, String, String, java.util.Set ) 106 107 /** 108 * Method checkUnknownAttribute. 109 * 110 * @param parser 111 * @param strict 112 * @param tagName 113 * @param attribute 114 * @throws XmlPullParserException 115 * @throws IOException 116 */ 117 private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict ) 118 throws XmlPullParserException, IOException 119 { 120 // strictXmlAttributes = true for model: if strict == true, not only elements are checked but attributes too 121 if ( strict ) 122 { 123 throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null ); 124 } 125 } //-- void checkUnknownAttribute( XmlPullParser, String, String, boolean ) 126 127 /** 128 * Method checkUnknownElement. 129 * 130 * @param parser 131 * @param strict 132 * @throws XmlPullParserException 133 * @throws IOException 134 */ 135 private void checkUnknownElement( XmlPullParser parser, boolean strict ) 136 throws XmlPullParserException, IOException 137 { 138 if ( strict ) 139 { 140 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null ); 141 } 142 143 for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; ) 144 { 145 int eventType = parser.next(); 146 if ( eventType == XmlPullParser.START_TAG ) 147 { 148 unrecognizedTagCount++; 149 } 150 else if ( eventType == XmlPullParser.END_TAG ) 151 { 152 unrecognizedTagCount--; 153 } 154 } 155 } //-- void checkUnknownElement( XmlPullParser, boolean ) 156 157 /** 158 * Returns the state of the "add default entities" flag. 159 * 160 * @return boolean 161 */ 162 public boolean getAddDefaultEntities() 163 { 164 return addDefaultEntities; 165 } //-- boolean getAddDefaultEntities() 166 167 /** 168 * Method getBooleanValue. 169 * 170 * @param s 171 * @param parser 172 * @param attribute 173 * @throws XmlPullParserException 174 * @return boolean 175 */ 176 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser ) 177 throws XmlPullParserException 178 { 179 return getBooleanValue( s, attribute, parser, null ); 180 } //-- boolean getBooleanValue( String, String, XmlPullParser ) 181 182 /** 183 * Method getBooleanValue. 184 * 185 * @param s 186 * @param defaultValue 187 * @param parser 188 * @param attribute 189 * @throws XmlPullParserException 190 * @return boolean 191 */ 192 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue ) 193 throws XmlPullParserException 194 { 195 if ( s != null && s.length() != 0 ) 196 { 197 return Boolean.valueOf( s ).booleanValue(); 198 } 199 if ( defaultValue != null ) 200 { 201 return Boolean.valueOf( defaultValue ).booleanValue(); 202 } 203 return false; 204 } //-- boolean getBooleanValue( String, String, XmlPullParser, String ) 205 206 /** 207 * Method getByteValue. 208 * 209 * @param s 210 * @param strict 211 * @param parser 212 * @param attribute 213 * @throws XmlPullParserException 214 * @return byte 215 */ 216 private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict ) 217 throws XmlPullParserException 218 { 219 if ( s != null ) 220 { 221 try 222 { 223 return Byte.valueOf( s ).byteValue(); 224 } 225 catch ( NumberFormatException nfe ) 226 { 227 if ( strict ) 228 { 229 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe ); 230 } 231 } 232 } 233 return 0; 234 } //-- byte getByteValue( String, String, XmlPullParser, boolean ) 235 236 /** 237 * Method getCharacterValue. 238 * 239 * @param s 240 * @param parser 241 * @param attribute 242 * @throws XmlPullParserException 243 * @return char 244 */ 245 private char getCharacterValue( String s, String attribute, XmlPullParser parser ) 246 throws XmlPullParserException 247 { 248 if ( s != null ) 249 { 250 return s.charAt( 0 ); 251 } 252 return 0; 253 } //-- char getCharacterValue( String, String, XmlPullParser ) 254 255 /** 256 * Method getDateValue. 257 * 258 * @param s 259 * @param parser 260 * @param attribute 261 * @throws XmlPullParserException 262 * @return Date 263 */ 264 private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser ) 265 throws XmlPullParserException 266 { 267 return getDateValue( s, attribute, null, parser ); 268 } //-- java.util.Date getDateValue( String, String, XmlPullParser ) 269 270 /** 271 * Method getDateValue. 272 * 273 * @param s 274 * @param parser 275 * @param dateFormat 276 * @param attribute 277 * @throws XmlPullParserException 278 * @return Date 279 */ 280 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser ) 281 throws XmlPullParserException 282 { 283 if ( s != null ) 284 { 285 String effectiveDateFormat = dateFormat; 286 if ( dateFormat == null ) 287 { 288 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS"; 289 } 290 if ( "long".equals( effectiveDateFormat ) ) 291 { 292 try 293 { 294 return new java.util.Date( Long.parseLong( s ) ); 295 } 296 catch ( NumberFormatException e ) 297 { 298 throw new XmlPullParserException( e.getMessage(), parser, e ); 299 } 300 } 301 else 302 { 303 try 304 { 305 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US ); 306 return dateParser.parse( s ); 307 } 308 catch ( java.text.ParseException e ) 309 { 310 throw new XmlPullParserException( e.getMessage(), parser, e ); 311 } 312 } 313 } 314 return null; 315 } //-- java.util.Date getDateValue( String, String, String, XmlPullParser ) 316 317 /** 318 * Method getDoubleValue. 319 * 320 * @param s 321 * @param strict 322 * @param parser 323 * @param attribute 324 * @throws XmlPullParserException 325 * @return double 326 */ 327 private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict ) 328 throws XmlPullParserException 329 { 330 if ( s != null ) 331 { 332 try 333 { 334 return Double.valueOf( s ).doubleValue(); 335 } 336 catch ( NumberFormatException nfe ) 337 { 338 if ( strict ) 339 { 340 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe ); 341 } 342 } 343 } 344 return 0; 345 } //-- double getDoubleValue( String, String, XmlPullParser, boolean ) 346 347 /** 348 * Method getFloatValue. 349 * 350 * @param s 351 * @param strict 352 * @param parser 353 * @param attribute 354 * @throws XmlPullParserException 355 * @return float 356 */ 357 private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict ) 358 throws XmlPullParserException 359 { 360 if ( s != null ) 361 { 362 try 363 { 364 return Float.valueOf( s ).floatValue(); 365 } 366 catch ( NumberFormatException nfe ) 367 { 368 if ( strict ) 369 { 370 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe ); 371 } 372 } 373 } 374 return 0; 375 } //-- float getFloatValue( String, String, XmlPullParser, boolean ) 376 377 /** 378 * Method getIntegerValue. 379 * 380 * @param s 381 * @param strict 382 * @param parser 383 * @param attribute 384 * @throws XmlPullParserException 385 * @return int 386 */ 387 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict ) 388 throws XmlPullParserException 389 { 390 if ( s != null ) 391 { 392 try 393 { 394 return Integer.valueOf( s ).intValue(); 395 } 396 catch ( NumberFormatException nfe ) 397 { 398 if ( strict ) 399 { 400 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe ); 401 } 402 } 403 } 404 return 0; 405 } //-- int getIntegerValue( String, String, XmlPullParser, boolean ) 406 407 /** 408 * Method getLongValue. 409 * 410 * @param s 411 * @param strict 412 * @param parser 413 * @param attribute 414 * @throws XmlPullParserException 415 * @return long 416 */ 417 private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict ) 418 throws XmlPullParserException 419 { 420 if ( s != null ) 421 { 422 try 423 { 424 return Long.valueOf( s ).longValue(); 425 } 426 catch ( NumberFormatException nfe ) 427 { 428 if ( strict ) 429 { 430 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe ); 431 } 432 } 433 } 434 return 0; 435 } //-- long getLongValue( String, String, XmlPullParser, boolean ) 436 437 /** 438 * Method getRequiredAttributeValue. 439 * 440 * @param s 441 * @param strict 442 * @param parser 443 * @param attribute 444 * @throws XmlPullParserException 445 * @return String 446 */ 447 private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict ) 448 throws XmlPullParserException 449 { 450 if ( s == null ) 451 { 452 if ( strict ) 453 { 454 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null ); 455 } 456 } 457 return s; 458 } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean ) 459 460 /** 461 * Method getShortValue. 462 * 463 * @param s 464 * @param strict 465 * @param parser 466 * @param attribute 467 * @throws XmlPullParserException 468 * @return short 469 */ 470 private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict ) 471 throws XmlPullParserException 472 { 473 if ( s != null ) 474 { 475 try 476 { 477 return Short.valueOf( s ).shortValue(); 478 } 479 catch ( NumberFormatException nfe ) 480 { 481 if ( strict ) 482 { 483 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe ); 484 } 485 } 486 } 487 return 0; 488 } //-- short getShortValue( String, String, XmlPullParser, boolean ) 489 490 /** 491 * Method getTrimmedValue. 492 * 493 * @param s 494 * @return String 495 */ 496 private String getTrimmedValue( String s ) 497 { 498 if ( s != null ) 499 { 500 s = s.trim(); 501 } 502 return s; 503 } //-- String getTrimmedValue( String ) 504 505 /** 506 * Method interpolatedTrimmed. 507 * 508 * @param value 509 * @param context 510 * @return String 511 */ 512 private String interpolatedTrimmed( String value, String context ) 513 { 514 return getTrimmedValue( contentTransformer.transform( value, context ) ); 515 } //-- String interpolatedTrimmed( String, String ) 516 517 /** 518 * Method nextTag. 519 * 520 * @param parser 521 * @throws IOException 522 * @throws XmlPullParserException 523 * @return int 524 */ 525 private int nextTag( XmlPullParser parser ) 526 throws IOException, XmlPullParserException 527 { 528 int eventType = parser.next(); 529 if ( eventType == XmlPullParser.TEXT ) 530 { 531 eventType = parser.next(); 532 } 533 if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG ) 534 { 535 throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null ); 536 } 537 return eventType; 538 } //-- int nextTag( XmlPullParser ) 539 540 /** 541 * @see ReaderFactory#newXmlReader 542 * 543 * @param reader 544 * @param strict 545 * @throws IOException 546 * @throws XmlPullParserException 547 * @return PluginMetadata 548 */ 549 public PluginMetadata read( Reader reader, boolean strict ) 550 throws IOException, XmlPullParserException 551 { 552 XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( ); 553 554 parser.setInput( reader ); 555 556 557 return read( parser, strict ); 558 } //-- PluginMetadata read( Reader, boolean ) 559 560 /** 561 * @see ReaderFactory#newXmlReader 562 * 563 * @param reader 564 * @throws IOException 565 * @throws XmlPullParserException 566 * @return PluginMetadata 567 */ 568 public PluginMetadata read( Reader reader ) 569 throws IOException, XmlPullParserException 570 { 571 return read( reader, true ); 572 } //-- PluginMetadata read( Reader ) 573 574 /** 575 * Method read. 576 * 577 * @param in 578 * @param strict 579 * @throws IOException 580 * @throws XmlPullParserException 581 * @return PluginMetadata 582 */ 583 public PluginMetadata read( InputStream in, boolean strict ) 584 throws IOException, XmlPullParserException 585 { 586 return read( ReaderFactory.newXmlReader( in ), strict ); 587 } //-- PluginMetadata read( InputStream, boolean ) 588 589 /** 590 * Method read. 591 * 592 * @param in 593 * @throws IOException 594 * @throws XmlPullParserException 595 * @return PluginMetadata 596 */ 597 public PluginMetadata read( InputStream in ) 598 throws IOException, XmlPullParserException 599 { 600 return read( ReaderFactory.newXmlReader( in ) ); 601 } //-- PluginMetadata read( InputStream ) 602 603 /** 604 * Method parseComponent. 605 * 606 * @param parser 607 * @param strict 608 * @throws IOException 609 * @throws XmlPullParserException 610 * @return Component 611 */ 612 private Component parseComponent( XmlPullParser parser, boolean strict ) 613 throws IOException, XmlPullParserException 614 { 615 String tagName = parser.getName(); 616 Component component = new Component(); 617 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 618 { 619 String name = parser.getAttributeName( i ); 620 String value = parser.getAttributeValue( i ); 621 622 if ( name.indexOf( ':' ) >= 0 ) 623 { 624 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 625 } 626 else 627 { 628 checkUnknownAttribute( parser, name, tagName, strict ); 629 } 630 } 631 java.util.Set parsed = new java.util.HashSet(); 632 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 633 { 634 if ( checkFieldWithDuplicate( parser, "role", null, parsed ) ) 635 { 636 component.setRole( interpolatedTrimmed( parser.nextText(), "role" ) ); 637 } 638 else if ( checkFieldWithDuplicate( parser, "hint", null, parsed ) ) 639 { 640 component.setHint( interpolatedTrimmed( parser.nextText(), "hint" ) ); 641 } 642 else 643 { 644 checkUnknownElement( parser, strict ); 645 } 646 } 647 return component; 648 } //-- Component parseComponent( XmlPullParser, boolean ) 649 650 /** 651 * Method parseLifecycleExecution. 652 * 653 * @param parser 654 * @param strict 655 * @throws IOException 656 * @throws XmlPullParserException 657 * @return LifecycleExecution 658 */ 659 private LifecycleExecution parseLifecycleExecution( XmlPullParser parser, boolean strict ) 660 throws IOException, XmlPullParserException 661 { 662 String tagName = parser.getName(); 663 LifecycleExecution lifecycleExecution = new LifecycleExecution(); 664 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 665 { 666 String name = parser.getAttributeName( i ); 667 String value = parser.getAttributeValue( i ); 668 669 if ( name.indexOf( ':' ) >= 0 ) 670 { 671 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 672 } 673 else 674 { 675 checkUnknownAttribute( parser, name, tagName, strict ); 676 } 677 } 678 java.util.Set parsed = new java.util.HashSet(); 679 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 680 { 681 if ( checkFieldWithDuplicate( parser, "lifecycle", null, parsed ) ) 682 { 683 lifecycleExecution.setLifecycle( interpolatedTrimmed( parser.nextText(), "lifecycle" ) ); 684 } 685 else if ( checkFieldWithDuplicate( parser, "phase", null, parsed ) ) 686 { 687 lifecycleExecution.setPhase( interpolatedTrimmed( parser.nextText(), "phase" ) ); 688 } 689 else if ( checkFieldWithDuplicate( parser, "goal", null, parsed ) ) 690 { 691 lifecycleExecution.setGoal( interpolatedTrimmed( parser.nextText(), "goal" ) ); 692 } 693 else 694 { 695 checkUnknownElement( parser, strict ); 696 } 697 } 698 return lifecycleExecution; 699 } //-- LifecycleExecution parseLifecycleExecution( XmlPullParser, boolean ) 700 701 /** 702 * Method parseMojo. 703 * 704 * @param parser 705 * @param strict 706 * @throws IOException 707 * @throws XmlPullParserException 708 * @return Mojo 709 */ 710 private Mojo parseMojo( XmlPullParser parser, boolean strict ) 711 throws IOException, XmlPullParserException 712 { 713 String tagName = parser.getName(); 714 Mojo mojo = new Mojo(); 715 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 716 { 717 String name = parser.getAttributeName( i ); 718 String value = parser.getAttributeValue( i ); 719 720 if ( name.indexOf( ':' ) >= 0 ) 721 { 722 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 723 } 724 else 725 { 726 checkUnknownAttribute( parser, name, tagName, strict ); 727 } 728 } 729 java.util.Set parsed = new java.util.HashSet(); 730 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 731 { 732 if ( checkFieldWithDuplicate( parser, "goal", null, parsed ) ) 733 { 734 mojo.setGoal( interpolatedTrimmed( parser.nextText(), "goal" ) ); 735 } 736 else if ( checkFieldWithDuplicate( parser, "phase", null, parsed ) ) 737 { 738 mojo.setPhase( interpolatedTrimmed( parser.nextText(), "phase" ) ); 739 } 740 else if ( checkFieldWithDuplicate( parser, "aggregator", null, parsed ) ) 741 { 742 mojo.setAggregator( getBooleanValue( interpolatedTrimmed( parser.nextText(), "aggregator" ), "aggregator", parser, "false" ) ); 743 } 744 else if ( checkFieldWithDuplicate( parser, "requiresDependencyResolution", null, parsed ) ) 745 { 746 mojo.setRequiresDependencyResolution( interpolatedTrimmed( parser.nextText(), "requiresDependencyResolution" ) ); 747 } 748 else if ( checkFieldWithDuplicate( parser, "requiresProject", null, parsed ) ) 749 { 750 mojo.setRequiresProject( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresProject" ), "requiresProject", parser, "false" ) ); 751 } 752 else if ( checkFieldWithDuplicate( parser, "requiresReports", null, parsed ) ) 753 { 754 mojo.setRequiresReports( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresReports" ), "requiresReports", parser, "false" ) ); 755 } 756 else if ( checkFieldWithDuplicate( parser, "requiresOnline", null, parsed ) ) 757 { 758 mojo.setRequiresOnline( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresOnline" ), "requiresOnline", parser, "false" ) ); 759 } 760 else if ( checkFieldWithDuplicate( parser, "inheritByDefault", null, parsed ) ) 761 { 762 mojo.setInheritByDefault( getBooleanValue( interpolatedTrimmed( parser.nextText(), "inheritByDefault" ), "inheritByDefault", parser, "false" ) ); 763 } 764 else if ( checkFieldWithDuplicate( parser, "requiresDirectInvocation", null, parsed ) ) 765 { 766 mojo.setRequiresDirectInvocation( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresDirectInvocation" ), "requiresDirectInvocation", parser, "false" ) ); 767 } 768 else if ( checkFieldWithDuplicate( parser, "execution", null, parsed ) ) 769 { 770 mojo.setExecution( parseLifecycleExecution( parser, strict ) ); 771 } 772 else if ( checkFieldWithDuplicate( parser, "components", null, parsed ) ) 773 { 774 java.util.List<Component> components = new java.util.ArrayList<Component>(); 775 mojo.setComponents( components ); 776 while ( parser.nextTag() == XmlPullParser.START_TAG ) 777 { 778 if ( "component".equals( parser.getName() ) ) 779 { 780 components.add( parseComponent( parser, strict ) ); 781 } 782 else 783 { 784 checkUnknownElement( parser, strict ); 785 } 786 } 787 } 788 else if ( checkFieldWithDuplicate( parser, "parameters", null, parsed ) ) 789 { 790 java.util.List<Parameter> parameters = new java.util.ArrayList<Parameter>(); 791 mojo.setParameters( parameters ); 792 while ( parser.nextTag() == XmlPullParser.START_TAG ) 793 { 794 if ( "parameter".equals( parser.getName() ) ) 795 { 796 parameters.add( parseParameter( parser, strict ) ); 797 } 798 else 799 { 800 checkUnknownElement( parser, strict ); 801 } 802 } 803 } 804 else if ( checkFieldWithDuplicate( parser, "description", null, parsed ) ) 805 { 806 mojo.setDescription( interpolatedTrimmed( parser.nextText(), "description" ) ); 807 } 808 else if ( checkFieldWithDuplicate( parser, "deprecated", null, parsed ) ) 809 { 810 mojo.setDeprecation( interpolatedTrimmed( parser.nextText(), "deprecated" ) ); 811 } 812 else if ( checkFieldWithDuplicate( parser, "since", null, parsed ) ) 813 { 814 mojo.setSince( interpolatedTrimmed( parser.nextText(), "since" ) ); 815 } 816 else if ( checkFieldWithDuplicate( parser, "call", null, parsed ) ) 817 { 818 mojo.setCall( interpolatedTrimmed( parser.nextText(), "call" ) ); 819 } 820 else 821 { 822 checkUnknownElement( parser, strict ); 823 } 824 } 825 return mojo; 826 } //-- Mojo parseMojo( XmlPullParser, boolean ) 827 828 /** 829 * Method parseParameter. 830 * 831 * @param parser 832 * @param strict 833 * @throws IOException 834 * @throws XmlPullParserException 835 * @return Parameter 836 */ 837 private Parameter parseParameter( XmlPullParser parser, boolean strict ) 838 throws IOException, XmlPullParserException 839 { 840 String tagName = parser.getName(); 841 Parameter parameter = new Parameter(); 842 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 843 { 844 String name = parser.getAttributeName( i ); 845 String value = parser.getAttributeValue( i ); 846 847 if ( name.indexOf( ':' ) >= 0 ) 848 { 849 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 850 } 851 else 852 { 853 checkUnknownAttribute( parser, name, tagName, strict ); 854 } 855 } 856 java.util.Set parsed = new java.util.HashSet(); 857 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 858 { 859 if ( checkFieldWithDuplicate( parser, "name", null, parsed ) ) 860 { 861 parameter.setName( interpolatedTrimmed( parser.nextText(), "name" ) ); 862 } 863 else if ( checkFieldWithDuplicate( parser, "alias", null, parsed ) ) 864 { 865 parameter.setAlias( interpolatedTrimmed( parser.nextText(), "alias" ) ); 866 } 867 else if ( checkFieldWithDuplicate( parser, "property", null, parsed ) ) 868 { 869 parameter.setProperty( interpolatedTrimmed( parser.nextText(), "property" ) ); 870 } 871 else if ( checkFieldWithDuplicate( parser, "required", null, parsed ) ) 872 { 873 parameter.setRequired( getBooleanValue( interpolatedTrimmed( parser.nextText(), "required" ), "required", parser, "false" ) ); 874 } 875 else if ( checkFieldWithDuplicate( parser, "readonly", null, parsed ) ) 876 { 877 parameter.setReadonly( getBooleanValue( interpolatedTrimmed( parser.nextText(), "readonly" ), "readonly", parser, "false" ) ); 878 } 879 else if ( checkFieldWithDuplicate( parser, "expression", null, parsed ) ) 880 { 881 parameter.setExpression( interpolatedTrimmed( parser.nextText(), "expression" ) ); 882 } 883 else if ( checkFieldWithDuplicate( parser, "defaultValue", null, parsed ) ) 884 { 885 parameter.setDefaultValue( interpolatedTrimmed( parser.nextText(), "defaultValue" ) ); 886 } 887 else if ( checkFieldWithDuplicate( parser, "type", null, parsed ) ) 888 { 889 parameter.setType( interpolatedTrimmed( parser.nextText(), "type" ) ); 890 } 891 else if ( checkFieldWithDuplicate( parser, "description", null, parsed ) ) 892 { 893 parameter.setDescription( interpolatedTrimmed( parser.nextText(), "description" ) ); 894 } 895 else if ( checkFieldWithDuplicate( parser, "deprecated", null, parsed ) ) 896 { 897 parameter.setDeprecation( interpolatedTrimmed( parser.nextText(), "deprecated" ) ); 898 } 899 else if ( checkFieldWithDuplicate( parser, "since", null, parsed ) ) 900 { 901 parameter.setSince( interpolatedTrimmed( parser.nextText(), "since" ) ); 902 } 903 else 904 { 905 checkUnknownElement( parser, strict ); 906 } 907 } 908 return parameter; 909 } //-- Parameter parseParameter( XmlPullParser, boolean ) 910 911 /** 912 * Method parsePluginMetadata. 913 * 914 * @param parser 915 * @param strict 916 * @throws IOException 917 * @throws XmlPullParserException 918 * @return PluginMetadata 919 */ 920 private PluginMetadata parsePluginMetadata( XmlPullParser parser, boolean strict ) 921 throws IOException, XmlPullParserException 922 { 923 String tagName = parser.getName(); 924 PluginMetadata pluginMetadata = new PluginMetadata(); 925 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 926 { 927 String name = parser.getAttributeName( i ); 928 String value = parser.getAttributeValue( i ); 929 930 if ( name.indexOf( ':' ) >= 0 ) 931 { 932 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 933 } 934 else if ( "xmlns".equals( name ) ) 935 { 936 // ignore xmlns attribute in root class, which is a reserved attribute name 937 } 938 else 939 { 940 checkUnknownAttribute( parser, name, tagName, strict ); 941 } 942 } 943 java.util.Set parsed = new java.util.HashSet(); 944 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 945 { 946 if ( checkFieldWithDuplicate( parser, "mojos", null, parsed ) ) 947 { 948 java.util.List<Mojo> mojos = new java.util.ArrayList<Mojo>(); 949 pluginMetadata.setMojos( mojos ); 950 while ( parser.nextTag() == XmlPullParser.START_TAG ) 951 { 952 if ( "mojo".equals( parser.getName() ) ) 953 { 954 mojos.add( parseMojo( parser, strict ) ); 955 } 956 else 957 { 958 checkUnknownElement( parser, strict ); 959 } 960 } 961 } 962 else 963 { 964 checkUnknownElement( parser, strict ); 965 } 966 } 967 return pluginMetadata; 968 } //-- PluginMetadata parsePluginMetadata( XmlPullParser, boolean ) 969 970 /** 971 * Method read. 972 * 973 * @param parser 974 * @param strict 975 * @throws IOException 976 * @throws XmlPullParserException 977 * @return PluginMetadata 978 */ 979 private PluginMetadata read( XmlPullParser parser, boolean strict ) 980 throws IOException, XmlPullParserException 981 { 982 PluginMetadata pluginMetadata = null; 983 int eventType = parser.getEventType(); 984 boolean parsed = false; 985 while ( eventType != XmlPullParser.END_DOCUMENT ) 986 { 987 if ( eventType == XmlPullParser.START_TAG ) 988 { 989 if ( strict && ! "pluginMetadata".equals( parser.getName() ) ) 990 { 991 throw new XmlPullParserException( "Expected root element 'pluginMetadata' but found '" + parser.getName() + "'", parser, null ); 992 } 993 else if ( parsed ) 994 { 995 // fallback, already expected a XmlPullParserException due to invalid XML 996 throw new XmlPullParserException( "Duplicated tag: 'pluginMetadata'", parser, null ); 997 } 998 pluginMetadata = parsePluginMetadata( parser, strict ); 999 pluginMetadata.setModelEncoding( parser.getInputEncoding() ); 1000 parsed = true; 1001 } 1002 eventType = parser.next(); 1003 } 1004 if ( parsed ) 1005 { 1006 return pluginMetadata; 1007 } 1008 throw new XmlPullParserException( "Expected root element 'pluginMetadata' but found no element at all: invalid XML document", parser, null ); 1009 } //-- PluginMetadata read( XmlPullParser, boolean ) 1010 1011 /** 1012 * Sets the state of the "add default entities" flag. 1013 * 1014 * @param addDefaultEntities 1015 */ 1016 public void setAddDefaultEntities( boolean addDefaultEntities ) 1017 { 1018 this.addDefaultEntities = addDefaultEntities; 1019 } //-- void setAddDefaultEntities( boolean ) 1020 1021 public static interface ContentTransformer 1022{ 1023 /** 1024 * Interpolate the value read from the xpp3 document 1025 * @param source The source value 1026 * @param fieldName A description of the field being interpolated. The implementation may use this to 1027 * log stuff. 1028 * @return The interpolated value. 1029 */ 1030 String transform( String source, String fieldName ); 1031} 1032 1033}