001// =================== DO NOT EDIT THIS FILE ==================== 002// Generated by Modello 1.8.3, 003// any modifications will be overwritten. 004// ============================================================== 005 006package org.apache.maven.artifact.repository.metadata.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.artifact.repository.metadata.Metadata; 017import org.apache.maven.artifact.repository.metadata.Plugin; 018import org.apache.maven.artifact.repository.metadata.Snapshot; 019import org.apache.maven.artifact.repository.metadata.SnapshotVersion; 020import org.apache.maven.artifact.repository.metadata.Versioning; 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 MetadataXpp3Reader. 029 * 030 * @version $Revision: 965443 $ $Date: 2015-09-14 22:18:52 +0000 (Mon, 14 Sep 2015) $ 031 */ 032@SuppressWarnings( "all" ) 033public class MetadataXpp3Reader 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 MetadataXpp3Reader() 063 { 064 this( new ContentTransformer() 065 { 066 public String transform( String source, String fieldName ) 067 { 068 return source; 069 } 070 } ); 071 } //-- org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader() 072 073 public MetadataXpp3Reader(ContentTransformer contentTransformer) 074 { 075 this.contentTransformer = contentTransformer; 076 } //-- org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader(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 Metadata 548 */ 549 public Metadata 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 } //-- Metadata read( Reader, boolean ) 559 560 /** 561 * @see ReaderFactory#newXmlReader 562 * 563 * @param reader 564 * @throws IOException 565 * @throws XmlPullParserException 566 * @return Metadata 567 */ 568 public Metadata read( Reader reader ) 569 throws IOException, XmlPullParserException 570 { 571 return read( reader, true ); 572 } //-- Metadata read( Reader ) 573 574 /** 575 * Method read. 576 * 577 * @param in 578 * @param strict 579 * @throws IOException 580 * @throws XmlPullParserException 581 * @return Metadata 582 */ 583 public Metadata read( InputStream in, boolean strict ) 584 throws IOException, XmlPullParserException 585 { 586 return read( ReaderFactory.newXmlReader( in ), strict ); 587 } //-- Metadata read( InputStream, boolean ) 588 589 /** 590 * Method read. 591 * 592 * @param in 593 * @throws IOException 594 * @throws XmlPullParserException 595 * @return Metadata 596 */ 597 public Metadata read( InputStream in ) 598 throws IOException, XmlPullParserException 599 { 600 return read( ReaderFactory.newXmlReader( in ) ); 601 } //-- Metadata read( InputStream ) 602 603 /** 604 * Method parseMetadata. 605 * 606 * @param parser 607 * @param strict 608 * @throws IOException 609 * @throws XmlPullParserException 610 * @return Metadata 611 */ 612 private Metadata parseMetadata( XmlPullParser parser, boolean strict ) 613 throws IOException, XmlPullParserException 614 { 615 String tagName = parser.getName(); 616 Metadata metadata = new Metadata(); 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 if ( "xmlns".equals( name ) ) 627 { 628 // ignore xmlns attribute in root class, which is a reserved attribute name 629 } 630 else if ( "modelVersion".equals( name ) ) 631 { 632 metadata.setModelVersion( interpolatedTrimmed( value, "modelVersion" ) ); 633 } 634 else 635 { 636 checkUnknownAttribute( parser, name, tagName, strict ); 637 } 638 } 639 java.util.Set parsed = new java.util.HashSet(); 640 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 641 { 642 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) ) 643 { 644 metadata.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) ); 645 } 646 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) ) 647 { 648 metadata.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) ); 649 } 650 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) ) 651 { 652 metadata.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) ); 653 } 654 else if ( checkFieldWithDuplicate( parser, "versioning", null, parsed ) ) 655 { 656 metadata.setVersioning( parseVersioning( parser, strict ) ); 657 } 658 else if ( checkFieldWithDuplicate( parser, "plugins", null, parsed ) ) 659 { 660 java.util.List plugins = new java.util.ArrayList/*<Plugin>*/(); 661 metadata.setPlugins( plugins ); 662 while ( parser.nextTag() == XmlPullParser.START_TAG ) 663 { 664 if ( "plugin".equals( parser.getName() ) ) 665 { 666 plugins.add( parsePlugin( parser, strict ) ); 667 } 668 else 669 { 670 checkUnknownElement( parser, strict ); 671 } 672 } 673 } 674 else 675 { 676 checkUnknownElement( parser, strict ); 677 } 678 } 679 return metadata; 680 } //-- Metadata parseMetadata( XmlPullParser, boolean ) 681 682 /** 683 * Method parsePlugin. 684 * 685 * @param parser 686 * @param strict 687 * @throws IOException 688 * @throws XmlPullParserException 689 * @return Plugin 690 */ 691 private Plugin parsePlugin( XmlPullParser parser, boolean strict ) 692 throws IOException, XmlPullParserException 693 { 694 String tagName = parser.getName(); 695 Plugin plugin = new Plugin(); 696 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 697 { 698 String name = parser.getAttributeName( i ); 699 String value = parser.getAttributeValue( i ); 700 701 if ( name.indexOf( ':' ) >= 0 ) 702 { 703 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 704 } 705 else 706 { 707 checkUnknownAttribute( parser, name, tagName, strict ); 708 } 709 } 710 java.util.Set parsed = new java.util.HashSet(); 711 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 712 { 713 if ( checkFieldWithDuplicate( parser, "name", null, parsed ) ) 714 { 715 plugin.setName( interpolatedTrimmed( parser.nextText(), "name" ) ); 716 } 717 else if ( checkFieldWithDuplicate( parser, "prefix", null, parsed ) ) 718 { 719 plugin.setPrefix( interpolatedTrimmed( parser.nextText(), "prefix" ) ); 720 } 721 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) ) 722 { 723 plugin.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) ); 724 } 725 else 726 { 727 checkUnknownElement( parser, strict ); 728 } 729 } 730 return plugin; 731 } //-- Plugin parsePlugin( XmlPullParser, boolean ) 732 733 /** 734 * Method parseSnapshot. 735 * 736 * @param parser 737 * @param strict 738 * @throws IOException 739 * @throws XmlPullParserException 740 * @return Snapshot 741 */ 742 private Snapshot parseSnapshot( XmlPullParser parser, boolean strict ) 743 throws IOException, XmlPullParserException 744 { 745 String tagName = parser.getName(); 746 Snapshot snapshot = new Snapshot(); 747 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 748 { 749 String name = parser.getAttributeName( i ); 750 String value = parser.getAttributeValue( i ); 751 752 if ( name.indexOf( ':' ) >= 0 ) 753 { 754 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 755 } 756 else 757 { 758 checkUnknownAttribute( parser, name, tagName, strict ); 759 } 760 } 761 java.util.Set parsed = new java.util.HashSet(); 762 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 763 { 764 if ( checkFieldWithDuplicate( parser, "timestamp", null, parsed ) ) 765 { 766 snapshot.setTimestamp( interpolatedTrimmed( parser.nextText(), "timestamp" ) ); 767 } 768 else if ( checkFieldWithDuplicate( parser, "buildNumber", null, parsed ) ) 769 { 770 snapshot.setBuildNumber( getIntegerValue( interpolatedTrimmed( parser.nextText(), "buildNumber" ), "buildNumber", parser, strict ) ); 771 } 772 else if ( checkFieldWithDuplicate( parser, "localCopy", null, parsed ) ) 773 { 774 snapshot.setLocalCopy( getBooleanValue( interpolatedTrimmed( parser.nextText(), "localCopy" ), "localCopy", parser, "false" ) ); 775 } 776 else 777 { 778 checkUnknownElement( parser, strict ); 779 } 780 } 781 return snapshot; 782 } //-- Snapshot parseSnapshot( XmlPullParser, boolean ) 783 784 /** 785 * Method parseSnapshotVersion. 786 * 787 * @param parser 788 * @param strict 789 * @throws IOException 790 * @throws XmlPullParserException 791 * @return SnapshotVersion 792 */ 793 private SnapshotVersion parseSnapshotVersion( XmlPullParser parser, boolean strict ) 794 throws IOException, XmlPullParserException 795 { 796 String tagName = parser.getName(); 797 SnapshotVersion snapshotVersion = new SnapshotVersion(); 798 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 799 { 800 String name = parser.getAttributeName( i ); 801 String value = parser.getAttributeValue( i ); 802 803 if ( name.indexOf( ':' ) >= 0 ) 804 { 805 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 806 } 807 else 808 { 809 checkUnknownAttribute( parser, name, tagName, strict ); 810 } 811 } 812 java.util.Set parsed = new java.util.HashSet(); 813 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 814 { 815 if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) ) 816 { 817 snapshotVersion.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) ); 818 } 819 else if ( checkFieldWithDuplicate( parser, "extension", null, parsed ) ) 820 { 821 snapshotVersion.setExtension( interpolatedTrimmed( parser.nextText(), "extension" ) ); 822 } 823 else if ( checkFieldWithDuplicate( parser, "value", null, parsed ) ) 824 { 825 snapshotVersion.setVersion( interpolatedTrimmed( parser.nextText(), "value" ) ); 826 } 827 else if ( checkFieldWithDuplicate( parser, "updated", null, parsed ) ) 828 { 829 snapshotVersion.setUpdated( interpolatedTrimmed( parser.nextText(), "updated" ) ); 830 } 831 else 832 { 833 checkUnknownElement( parser, strict ); 834 } 835 } 836 return snapshotVersion; 837 } //-- SnapshotVersion parseSnapshotVersion( XmlPullParser, boolean ) 838 839 /** 840 * Method parseVersioning. 841 * 842 * @param parser 843 * @param strict 844 * @throws IOException 845 * @throws XmlPullParserException 846 * @return Versioning 847 */ 848 private Versioning parseVersioning( XmlPullParser parser, boolean strict ) 849 throws IOException, XmlPullParserException 850 { 851 String tagName = parser.getName(); 852 Versioning versioning = new Versioning(); 853 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- ) 854 { 855 String name = parser.getAttributeName( i ); 856 String value = parser.getAttributeValue( i ); 857 858 if ( name.indexOf( ':' ) >= 0 ) 859 { 860 // just ignore attributes with non-default namespace (for example: xmlns:xsi) 861 } 862 else 863 { 864 checkUnknownAttribute( parser, name, tagName, strict ); 865 } 866 } 867 java.util.Set parsed = new java.util.HashSet(); 868 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG ) 869 { 870 if ( checkFieldWithDuplicate( parser, "latest", null, parsed ) ) 871 { 872 versioning.setLatest( interpolatedTrimmed( parser.nextText(), "latest" ) ); 873 } 874 else if ( checkFieldWithDuplicate( parser, "release", null, parsed ) ) 875 { 876 versioning.setRelease( interpolatedTrimmed( parser.nextText(), "release" ) ); 877 } 878 else if ( checkFieldWithDuplicate( parser, "snapshot", null, parsed ) ) 879 { 880 versioning.setSnapshot( parseSnapshot( parser, strict ) ); 881 } 882 else if ( checkFieldWithDuplicate( parser, "versions", null, parsed ) ) 883 { 884 java.util.List versions = new java.util.ArrayList/*<String>*/(); 885 versioning.setVersions( versions ); 886 while ( parser.nextTag() == XmlPullParser.START_TAG ) 887 { 888 if ( "version".equals( parser.getName() ) ) 889 { 890 versions.add( interpolatedTrimmed( parser.nextText(), "versions" ) ); 891 } 892 else 893 { 894 checkUnknownElement( parser, strict ); 895 } 896 } 897 } 898 else if ( checkFieldWithDuplicate( parser, "lastUpdated", null, parsed ) ) 899 { 900 versioning.setLastUpdated( interpolatedTrimmed( parser.nextText(), "lastUpdated" ) ); 901 } 902 else if ( checkFieldWithDuplicate( parser, "snapshotVersions", null, parsed ) ) 903 { 904 java.util.List snapshotVersions = new java.util.ArrayList/*<SnapshotVersion>*/(); 905 versioning.setSnapshotVersions( snapshotVersions ); 906 while ( parser.nextTag() == XmlPullParser.START_TAG ) 907 { 908 if ( "snapshotVersion".equals( parser.getName() ) ) 909 { 910 snapshotVersions.add( parseSnapshotVersion( parser, strict ) ); 911 } 912 else 913 { 914 checkUnknownElement( parser, strict ); 915 } 916 } 917 } 918 else 919 { 920 checkUnknownElement( parser, strict ); 921 } 922 } 923 return versioning; 924 } //-- Versioning parseVersioning( XmlPullParser, boolean ) 925 926 /** 927 * Method read. 928 * 929 * @param parser 930 * @param strict 931 * @throws IOException 932 * @throws XmlPullParserException 933 * @return Metadata 934 */ 935 private Metadata read( XmlPullParser parser, boolean strict ) 936 throws IOException, XmlPullParserException 937 { 938 int eventType = parser.getEventType(); 939 while ( eventType != XmlPullParser.END_DOCUMENT ) 940 { 941 if ( eventType == XmlPullParser.START_TAG ) 942 { 943 if ( strict && ! "metadata".equals( parser.getName() ) ) 944 { 945 throw new XmlPullParserException( "Expected root element 'metadata' but found '" + parser.getName() + "'", parser, null ); 946 } 947 Metadata metadata = parseMetadata( parser, strict ); 948 metadata.setModelEncoding( parser.getInputEncoding() ); 949 return metadata; 950 } 951 eventType = parser.next(); 952 } 953 throw new XmlPullParserException( "Expected root element 'metadata' but found no element at all: invalid XML document", parser, null ); 954 } //-- Metadata read( XmlPullParser, boolean ) 955 956 /** 957 * Sets the state of the "add default entities" flag. 958 * 959 * @param addDefaultEntities 960 */ 961 public void setAddDefaultEntities( boolean addDefaultEntities ) 962 { 963 this.addDefaultEntities = addDefaultEntities; 964 } //-- void setAddDefaultEntities( boolean ) 965 966 public static interface ContentTransformer 967{ 968 /** 969 * Interpolate the value read from the xpp3 document 970 * @param source The source value 971 * @param fieldName A description of the field being interpolated. The implementation may use this to 972 * log stuff. 973 * @return The interpolated value. 974 */ 975 String transform( String source, String fieldName ); 976} 977 978}