1
2
3
4
5 package org.apache.maven.model.v4;
6
7 import java.io.IOException;
8 import java.io.InputStream;
9 import java.io.Reader;
10 import java.text.DateFormat;
11 import java.util.ArrayList;
12 import java.util.Date;
13 import java.util.HashMap;
14 import java.util.HashSet;
15 import java.util.LinkedHashMap;
16 import java.util.List;
17 import java.util.Map;
18 import java.util.Set;
19 import org.apache.maven.api.annotations.Generated;
20 import org.apache.maven.internal.xml.XmlNodeBuilder;
21 import org.apache.maven.api.model.Model;
22 import org.apache.maven.api.model.ModelBase;
23 import org.apache.maven.api.model.PluginContainer;
24 import org.apache.maven.api.model.PluginConfiguration;
25 import org.apache.maven.api.model.BuildBase;
26 import org.apache.maven.api.model.Build;
27 import org.apache.maven.api.model.CiManagement;
28 import org.apache.maven.api.model.Notifier;
29 import org.apache.maven.api.model.Contributor;
30 import org.apache.maven.api.model.Dependency;
31 import org.apache.maven.api.model.Developer;
32 import org.apache.maven.api.model.Exclusion;
33 import org.apache.maven.api.model.IssueManagement;
34 import org.apache.maven.api.model.DistributionManagement;
35 import org.apache.maven.api.model.License;
36 import org.apache.maven.api.model.MailingList;
37 import org.apache.maven.api.model.Organization;
38 import org.apache.maven.api.model.PatternSet;
39 import org.apache.maven.api.model.Parent;
40 import org.apache.maven.api.model.Scm;
41 import org.apache.maven.api.model.FileSet;
42 import org.apache.maven.api.model.Resource;
43 import org.apache.maven.api.model.RepositoryBase;
44 import org.apache.maven.api.model.Repository;
45 import org.apache.maven.api.model.DeploymentRepository;
46 import org.apache.maven.api.model.RepositoryPolicy;
47 import org.apache.maven.api.model.Site;
48 import org.apache.maven.api.model.ConfigurationContainer;
49 import org.apache.maven.api.model.Plugin;
50 import org.apache.maven.api.model.PluginExecution;
51 import org.apache.maven.api.model.DependencyManagement;
52 import org.apache.maven.api.model.PluginManagement;
53 import org.apache.maven.api.model.Reporting;
54 import org.apache.maven.api.model.Profile;
55 import org.apache.maven.api.model.Activation;
56 import org.apache.maven.api.model.ActivationProperty;
57 import org.apache.maven.api.model.ActivationOS;
58 import org.apache.maven.api.model.ActivationFile;
59 import org.apache.maven.api.model.ReportPlugin;
60 import org.apache.maven.api.model.ReportSet;
61 import org.apache.maven.api.model.Prerequisites;
62 import org.apache.maven.api.model.Relocation;
63 import org.apache.maven.api.model.Extension;
64 import org.apache.maven.api.model.InputLocation;
65 import org.apache.maven.api.model.InputSource;
66 import org.codehaus.plexus.util.ReaderFactory;
67 import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
68 import org.codehaus.plexus.util.xml.pull.MXParser;
69 import org.codehaus.plexus.util.xml.pull.XmlPullParser;
70 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
71
72 @Generated
73 public class MavenXpp3Reader
74 {
75 private boolean addDefaultEntities = true;
76
77 private final ContentTransformer contentTransformer;
78
79 public MavenXpp3Reader()
80 {
81 this( ( s, f ) -> s );
82 }
83
84 public MavenXpp3Reader( ContentTransformer contentTransformer )
85 {
86 this.contentTransformer = contentTransformer;
87 }
88
89
90
91
92
93
94 public boolean getAddDefaultEntities()
95 {
96 return addDefaultEntities;
97 }
98
99
100
101
102
103
104 public void setAddDefaultEntities( boolean addDefaultEntities )
105 {
106 this.addDefaultEntities = addDefaultEntities;
107 }
108
109
110
111
112
113
114
115
116
117
118
119 public Model read( Reader reader, boolean strict )
120 throws IOException, XmlPullParserException
121 {
122 XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
123
124 parser.setInput( reader );
125
126
127 return read( parser, strict );
128 }
129
130
131
132
133
134
135
136
137
138
139 public Model read( Reader reader )
140 throws IOException, XmlPullParserException
141 {
142 return read( reader, true );
143 }
144
145
146
147
148
149
150
151
152
153
154
155 public Model read( InputStream in, boolean strict )
156 throws IOException, XmlPullParserException
157 {
158 return read( ReaderFactory.newXmlReader( in ), strict );
159 }
160
161
162
163
164
165
166
167
168
169
170 public Model read( InputStream in )
171 throws IOException, XmlPullParserException
172 {
173 return read( ReaderFactory.newXmlReader( in ) );
174 }
175
176
177
178
179
180
181
182
183
184
185
186 public Model read( XmlPullParser parser, boolean strict )
187 throws IOException, XmlPullParserException
188 {
189 Model model = null;
190 int eventType = parser.getEventType();
191 boolean parsed = false;
192 while ( eventType != XmlPullParser.END_DOCUMENT )
193 {
194 if ( eventType == XmlPullParser.START_TAG )
195 {
196 if ( strict && ! "project".equals( parser.getName() ) )
197 {
198 throw new XmlPullParserException( "Expected root element 'project' but found '" + parser.getName() + "'", parser, null );
199 }
200 else if ( parsed )
201 {
202
203 throw new XmlPullParserException( "Duplicated tag: 'project'", parser, null );
204 }
205 model = parseModel( parser, strict );
206 parsed = true;
207 }
208 eventType = parser.next();
209 }
210 if ( parsed )
211 {
212 return model;
213 }
214 throw new XmlPullParserException( "Expected root element 'project' but found no element at all: invalid XML document", parser, null );
215 }
216
217 private Model parseModel( XmlPullParser parser, boolean strict )
218 throws IOException, XmlPullParserException
219 {
220 String tagName = parser.getName();
221 Model.Builder model = Model.newBuilder( true );
222 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
223 {
224 String name = parser.getAttributeName( i );
225 String value = parser.getAttributeValue( i );
226 if ( name.indexOf( ':' ) >= 0 )
227 {
228
229 }
230 else if ( "xmlns".equals( name ) )
231 {
232
233 }
234 else if ( "child.project.url.inherit.append.path".equals( name ) )
235 {
236 model.childProjectUrlInheritAppendPath( interpolatedTrimmed( value, "child.project.url.inherit.append.path" ) );
237 }
238 else
239 {
240 checkUnknownAttribute( parser, name, tagName, strict );
241 }
242 }
243 Set<String> parsed = new HashSet<>();
244 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
245 {
246 String childName = unalias( parser.getName() );
247 if ( !parsed.add( childName ) )
248 {
249 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
250 }
251 switch ( childName )
252 {
253 case "modelVersion":
254 {
255 model.modelVersion( interpolatedTrimmed( parser.nextText(), "modelVersion" ) );
256 break;
257 }
258 case "parent":
259 {
260 model.parent( parseParent( parser, strict ) );
261 break;
262 }
263 case "groupId":
264 {
265 model.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
266 break;
267 }
268 case "artifactId":
269 {
270 model.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
271 break;
272 }
273 case "version":
274 {
275 model.version( interpolatedTrimmed( parser.nextText(), "version" ) );
276 break;
277 }
278 case "packaging":
279 {
280 model.packaging( interpolatedTrimmed( parser.nextText(), "packaging" ) );
281 break;
282 }
283 case "name":
284 {
285 model.name( interpolatedTrimmed( parser.nextText(), "name" ) );
286 break;
287 }
288 case "description":
289 {
290 model.description( interpolatedTrimmed( parser.nextText(), "description" ) );
291 break;
292 }
293 case "url":
294 {
295 model.url( interpolatedTrimmed( parser.nextText(), "url" ) );
296 break;
297 }
298 case "inceptionYear":
299 {
300 model.inceptionYear( interpolatedTrimmed( parser.nextText(), "inceptionYear" ) );
301 break;
302 }
303 case "organization":
304 {
305 model.organization( parseOrganization( parser, strict ) );
306 break;
307 }
308 case "licenses":
309 {
310 List<License> licenses = new ArrayList<>();
311 while ( parser.nextTag() == XmlPullParser.START_TAG )
312 {
313 if ( "license".equals( parser.getName() ) )
314 {
315 licenses.add( parseLicense( parser, strict ) );
316 }
317 else
318 {
319 checkUnknownElement( parser, strict );
320 }
321 }
322 model.licenses( licenses );
323 break;
324 }
325 case "developers":
326 {
327 List<Developer> developers = new ArrayList<>();
328 while ( parser.nextTag() == XmlPullParser.START_TAG )
329 {
330 if ( "developer".equals( parser.getName() ) )
331 {
332 developers.add( parseDeveloper( parser, strict ) );
333 }
334 else
335 {
336 checkUnknownElement( parser, strict );
337 }
338 }
339 model.developers( developers );
340 break;
341 }
342 case "contributors":
343 {
344 List<Contributor> contributors = new ArrayList<>();
345 while ( parser.nextTag() == XmlPullParser.START_TAG )
346 {
347 if ( "contributor".equals( parser.getName() ) )
348 {
349 contributors.add( parseContributor( parser, strict ) );
350 }
351 else
352 {
353 checkUnknownElement( parser, strict );
354 }
355 }
356 model.contributors( contributors );
357 break;
358 }
359 case "mailingLists":
360 {
361 List<MailingList> mailingLists = new ArrayList<>();
362 while ( parser.nextTag() == XmlPullParser.START_TAG )
363 {
364 if ( "mailingList".equals( parser.getName() ) )
365 {
366 mailingLists.add( parseMailingList( parser, strict ) );
367 }
368 else
369 {
370 checkUnknownElement( parser, strict );
371 }
372 }
373 model.mailingLists( mailingLists );
374 break;
375 }
376 case "prerequisites":
377 {
378 model.prerequisites( parsePrerequisites( parser, strict ) );
379 break;
380 }
381 case "modules":
382 {
383 List<String> modules = new ArrayList<>();
384 while ( parser.nextTag() == XmlPullParser.START_TAG )
385 {
386 if ( "module".equals( parser.getName() ) )
387 {
388 modules.add( interpolatedTrimmed( parser.nextText(), "modules" ) );
389 }
390 else
391 {
392 checkUnknownElement( parser, strict );
393 }
394 }
395 model.modules( modules );
396 break;
397 }
398 case "scm":
399 {
400 model.scm( parseScm( parser, strict ) );
401 break;
402 }
403 case "issueManagement":
404 {
405 model.issueManagement( parseIssueManagement( parser, strict ) );
406 break;
407 }
408 case "ciManagement":
409 {
410 model.ciManagement( parseCiManagement( parser, strict ) );
411 break;
412 }
413 case "distributionManagement":
414 {
415 model.distributionManagement( parseDistributionManagement( parser, strict ) );
416 break;
417 }
418 case "properties":
419 {
420 Map<String, String> properties = new LinkedHashMap<>();
421 while ( parser.nextTag() == XmlPullParser.START_TAG )
422 {
423 String key = parser.getName();
424 String value = parser.nextText().trim();
425 properties.put( key, value );
426 }
427 model.properties( properties );
428 break;
429 }
430 case "dependencyManagement":
431 {
432 model.dependencyManagement( parseDependencyManagement( parser, strict ) );
433 break;
434 }
435 case "dependencies":
436 {
437 List<Dependency> dependencies = new ArrayList<>();
438 while ( parser.nextTag() == XmlPullParser.START_TAG )
439 {
440 if ( "dependency".equals( parser.getName() ) )
441 {
442 dependencies.add( parseDependency( parser, strict ) );
443 }
444 else
445 {
446 checkUnknownElement( parser, strict );
447 }
448 }
449 model.dependencies( dependencies );
450 break;
451 }
452 case "repositories":
453 {
454 List<Repository> repositories = new ArrayList<>();
455 while ( parser.nextTag() == XmlPullParser.START_TAG )
456 {
457 if ( "repository".equals( parser.getName() ) )
458 {
459 repositories.add( parseRepository( parser, strict ) );
460 }
461 else
462 {
463 checkUnknownElement( parser, strict );
464 }
465 }
466 model.repositories( repositories );
467 break;
468 }
469 case "pluginRepositories":
470 {
471 List<Repository> pluginRepositories = new ArrayList<>();
472 while ( parser.nextTag() == XmlPullParser.START_TAG )
473 {
474 if ( "pluginRepository".equals( parser.getName() ) )
475 {
476 pluginRepositories.add( parseRepository( parser, strict ) );
477 }
478 else
479 {
480 checkUnknownElement( parser, strict );
481 }
482 }
483 model.pluginRepositories( pluginRepositories );
484 break;
485 }
486 case "build":
487 {
488 model.build( parseBuild( parser, strict ) );
489 break;
490 }
491 case "reporting":
492 {
493 model.reporting( parseReporting( parser, strict ) );
494 break;
495 }
496 case "profiles":
497 {
498 List<Profile> profiles = new ArrayList<>();
499 while ( parser.nextTag() == XmlPullParser.START_TAG )
500 {
501 if ( "profile".equals( parser.getName() ) )
502 {
503 profiles.add( parseProfile( parser, strict ) );
504 }
505 else
506 {
507 checkUnknownElement( parser, strict );
508 }
509 }
510 model.profiles( profiles );
511 break;
512 }
513 default:
514 {
515 checkUnknownElement( parser, strict );
516 break;
517 }
518 }
519 }
520 model.modelEncoding( parser.getInputEncoding() );
521 return model.build();
522 }
523
524 private ModelBase parseModelBase( XmlPullParser parser, boolean strict )
525 throws IOException, XmlPullParserException
526 {
527 String tagName = parser.getName();
528 ModelBase.Builder modelBase = ModelBase.newBuilder( true );
529 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
530 {
531 String name = parser.getAttributeName( i );
532 String value = parser.getAttributeValue( i );
533 if ( name.indexOf( ':' ) >= 0 )
534 {
535
536 }
537 else
538 {
539 checkUnknownAttribute( parser, name, tagName, strict );
540 }
541 }
542 Set<String> parsed = new HashSet<>();
543 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
544 {
545 String childName = unalias( parser.getName() );
546 if ( !parsed.add( childName ) )
547 {
548 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
549 }
550 switch ( childName )
551 {
552 case "modules":
553 {
554 List<String> modules = new ArrayList<>();
555 while ( parser.nextTag() == XmlPullParser.START_TAG )
556 {
557 if ( "module".equals( parser.getName() ) )
558 {
559 modules.add( interpolatedTrimmed( parser.nextText(), "modules" ) );
560 }
561 else
562 {
563 checkUnknownElement( parser, strict );
564 }
565 }
566 modelBase.modules( modules );
567 break;
568 }
569 case "distributionManagement":
570 {
571 modelBase.distributionManagement( parseDistributionManagement( parser, strict ) );
572 break;
573 }
574 case "properties":
575 {
576 Map<String, String> properties = new LinkedHashMap<>();
577 while ( parser.nextTag() == XmlPullParser.START_TAG )
578 {
579 String key = parser.getName();
580 String value = parser.nextText().trim();
581 properties.put( key, value );
582 }
583 modelBase.properties( properties );
584 break;
585 }
586 case "dependencyManagement":
587 {
588 modelBase.dependencyManagement( parseDependencyManagement( parser, strict ) );
589 break;
590 }
591 case "dependencies":
592 {
593 List<Dependency> dependencies = new ArrayList<>();
594 while ( parser.nextTag() == XmlPullParser.START_TAG )
595 {
596 if ( "dependency".equals( parser.getName() ) )
597 {
598 dependencies.add( parseDependency( parser, strict ) );
599 }
600 else
601 {
602 checkUnknownElement( parser, strict );
603 }
604 }
605 modelBase.dependencies( dependencies );
606 break;
607 }
608 case "repositories":
609 {
610 List<Repository> repositories = new ArrayList<>();
611 while ( parser.nextTag() == XmlPullParser.START_TAG )
612 {
613 if ( "repository".equals( parser.getName() ) )
614 {
615 repositories.add( parseRepository( parser, strict ) );
616 }
617 else
618 {
619 checkUnknownElement( parser, strict );
620 }
621 }
622 modelBase.repositories( repositories );
623 break;
624 }
625 case "pluginRepositories":
626 {
627 List<Repository> pluginRepositories = new ArrayList<>();
628 while ( parser.nextTag() == XmlPullParser.START_TAG )
629 {
630 if ( "pluginRepository".equals( parser.getName() ) )
631 {
632 pluginRepositories.add( parseRepository( parser, strict ) );
633 }
634 else
635 {
636 checkUnknownElement( parser, strict );
637 }
638 }
639 modelBase.pluginRepositories( pluginRepositories );
640 break;
641 }
642 case "reporting":
643 {
644 modelBase.reporting( parseReporting( parser, strict ) );
645 break;
646 }
647 default:
648 {
649 checkUnknownElement( parser, strict );
650 break;
651 }
652 }
653 }
654 return modelBase.build();
655 }
656
657 private PluginContainer parsePluginContainer( XmlPullParser parser, boolean strict )
658 throws IOException, XmlPullParserException
659 {
660 String tagName = parser.getName();
661 PluginContainer.Builder pluginContainer = PluginContainer.newBuilder( true );
662 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
663 {
664 String name = parser.getAttributeName( i );
665 String value = parser.getAttributeValue( i );
666 if ( name.indexOf( ':' ) >= 0 )
667 {
668
669 }
670 else
671 {
672 checkUnknownAttribute( parser, name, tagName, strict );
673 }
674 }
675 Set<String> parsed = new HashSet<>();
676 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
677 {
678 String childName = unalias( parser.getName() );
679 if ( !parsed.add( childName ) )
680 {
681 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
682 }
683 switch ( childName )
684 {
685 case "plugins":
686 {
687 List<Plugin> plugins = new ArrayList<>();
688 while ( parser.nextTag() == XmlPullParser.START_TAG )
689 {
690 if ( "plugin".equals( parser.getName() ) )
691 {
692 plugins.add( parsePlugin( parser, strict ) );
693 }
694 else
695 {
696 checkUnknownElement( parser, strict );
697 }
698 }
699 pluginContainer.plugins( plugins );
700 break;
701 }
702 default:
703 {
704 checkUnknownElement( parser, strict );
705 break;
706 }
707 }
708 }
709 return pluginContainer.build();
710 }
711
712 private PluginConfiguration parsePluginConfiguration( XmlPullParser parser, boolean strict )
713 throws IOException, XmlPullParserException
714 {
715 String tagName = parser.getName();
716 PluginConfiguration.Builder pluginConfiguration = PluginConfiguration.newBuilder( true );
717 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
718 {
719 String name = parser.getAttributeName( i );
720 String value = parser.getAttributeValue( i );
721 if ( name.indexOf( ':' ) >= 0 )
722 {
723
724 }
725 else
726 {
727 checkUnknownAttribute( parser, name, tagName, strict );
728 }
729 }
730 Set<String> parsed = new HashSet<>();
731 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
732 {
733 String childName = unalias( parser.getName() );
734 if ( !parsed.add( childName ) )
735 {
736 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
737 }
738 switch ( childName )
739 {
740 case "pluginManagement":
741 {
742 pluginConfiguration.pluginManagement( parsePluginManagement( parser, strict ) );
743 break;
744 }
745 case "plugins":
746 {
747 List<Plugin> plugins = new ArrayList<>();
748 while ( parser.nextTag() == XmlPullParser.START_TAG )
749 {
750 if ( "plugin".equals( parser.getName() ) )
751 {
752 plugins.add( parsePlugin( parser, strict ) );
753 }
754 else
755 {
756 checkUnknownElement( parser, strict );
757 }
758 }
759 pluginConfiguration.plugins( plugins );
760 break;
761 }
762 default:
763 {
764 checkUnknownElement( parser, strict );
765 break;
766 }
767 }
768 }
769 return pluginConfiguration.build();
770 }
771
772 private BuildBase parseBuildBase( XmlPullParser parser, boolean strict )
773 throws IOException, XmlPullParserException
774 {
775 String tagName = parser.getName();
776 BuildBase.Builder buildBase = BuildBase.newBuilder( true );
777 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
778 {
779 String name = parser.getAttributeName( i );
780 String value = parser.getAttributeValue( i );
781 if ( name.indexOf( ':' ) >= 0 )
782 {
783
784 }
785 else
786 {
787 checkUnknownAttribute( parser, name, tagName, strict );
788 }
789 }
790 Set<String> parsed = new HashSet<>();
791 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
792 {
793 String childName = unalias( parser.getName() );
794 if ( !parsed.add( childName ) )
795 {
796 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
797 }
798 switch ( childName )
799 {
800 case "defaultGoal":
801 {
802 buildBase.defaultGoal( interpolatedTrimmed( parser.nextText(), "defaultGoal" ) );
803 break;
804 }
805 case "resources":
806 {
807 List<Resource> resources = new ArrayList<>();
808 while ( parser.nextTag() == XmlPullParser.START_TAG )
809 {
810 if ( "resource".equals( parser.getName() ) )
811 {
812 resources.add( parseResource( parser, strict ) );
813 }
814 else
815 {
816 checkUnknownElement( parser, strict );
817 }
818 }
819 buildBase.resources( resources );
820 break;
821 }
822 case "testResources":
823 {
824 List<Resource> testResources = new ArrayList<>();
825 while ( parser.nextTag() == XmlPullParser.START_TAG )
826 {
827 if ( "testResource".equals( parser.getName() ) )
828 {
829 testResources.add( parseResource( parser, strict ) );
830 }
831 else
832 {
833 checkUnknownElement( parser, strict );
834 }
835 }
836 buildBase.testResources( testResources );
837 break;
838 }
839 case "directory":
840 {
841 buildBase.directory( interpolatedTrimmed( parser.nextText(), "directory" ) );
842 break;
843 }
844 case "finalName":
845 {
846 buildBase.finalName( interpolatedTrimmed( parser.nextText(), "finalName" ) );
847 break;
848 }
849 case "filters":
850 {
851 List<String> filters = new ArrayList<>();
852 while ( parser.nextTag() == XmlPullParser.START_TAG )
853 {
854 if ( "filter".equals( parser.getName() ) )
855 {
856 filters.add( interpolatedTrimmed( parser.nextText(), "filters" ) );
857 }
858 else
859 {
860 checkUnknownElement( parser, strict );
861 }
862 }
863 buildBase.filters( filters );
864 break;
865 }
866 case "pluginManagement":
867 {
868 buildBase.pluginManagement( parsePluginManagement( parser, strict ) );
869 break;
870 }
871 case "plugins":
872 {
873 List<Plugin> plugins = new ArrayList<>();
874 while ( parser.nextTag() == XmlPullParser.START_TAG )
875 {
876 if ( "plugin".equals( parser.getName() ) )
877 {
878 plugins.add( parsePlugin( parser, strict ) );
879 }
880 else
881 {
882 checkUnknownElement( parser, strict );
883 }
884 }
885 buildBase.plugins( plugins );
886 break;
887 }
888 default:
889 {
890 checkUnknownElement( parser, strict );
891 break;
892 }
893 }
894 }
895 return buildBase.build();
896 }
897
898 private Build parseBuild( XmlPullParser parser, boolean strict )
899 throws IOException, XmlPullParserException
900 {
901 String tagName = parser.getName();
902 Build.Builder build = Build.newBuilder( true );
903 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
904 {
905 String name = parser.getAttributeName( i );
906 String value = parser.getAttributeValue( i );
907 if ( name.indexOf( ':' ) >= 0 )
908 {
909
910 }
911 else
912 {
913 checkUnknownAttribute( parser, name, tagName, strict );
914 }
915 }
916 Set<String> parsed = new HashSet<>();
917 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
918 {
919 String childName = unalias( parser.getName() );
920 if ( !parsed.add( childName ) )
921 {
922 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
923 }
924 switch ( childName )
925 {
926 case "sourceDirectory":
927 {
928 build.sourceDirectory( interpolatedTrimmed( parser.nextText(), "sourceDirectory" ) );
929 break;
930 }
931 case "scriptSourceDirectory":
932 {
933 build.scriptSourceDirectory( interpolatedTrimmed( parser.nextText(), "scriptSourceDirectory" ) );
934 break;
935 }
936 case "testSourceDirectory":
937 {
938 build.testSourceDirectory( interpolatedTrimmed( parser.nextText(), "testSourceDirectory" ) );
939 break;
940 }
941 case "outputDirectory":
942 {
943 build.outputDirectory( interpolatedTrimmed( parser.nextText(), "outputDirectory" ) );
944 break;
945 }
946 case "testOutputDirectory":
947 {
948 build.testOutputDirectory( interpolatedTrimmed( parser.nextText(), "testOutputDirectory" ) );
949 break;
950 }
951 case "extensions":
952 {
953 List<Extension> extensions = new ArrayList<>();
954 while ( parser.nextTag() == XmlPullParser.START_TAG )
955 {
956 if ( "extension".equals( parser.getName() ) )
957 {
958 extensions.add( parseExtension( parser, strict ) );
959 }
960 else
961 {
962 checkUnknownElement( parser, strict );
963 }
964 }
965 build.extensions( extensions );
966 break;
967 }
968 case "defaultGoal":
969 {
970 build.defaultGoal( interpolatedTrimmed( parser.nextText(), "defaultGoal" ) );
971 break;
972 }
973 case "resources":
974 {
975 List<Resource> resources = new ArrayList<>();
976 while ( parser.nextTag() == XmlPullParser.START_TAG )
977 {
978 if ( "resource".equals( parser.getName() ) )
979 {
980 resources.add( parseResource( parser, strict ) );
981 }
982 else
983 {
984 checkUnknownElement( parser, strict );
985 }
986 }
987 build.resources( resources );
988 break;
989 }
990 case "testResources":
991 {
992 List<Resource> testResources = new ArrayList<>();
993 while ( parser.nextTag() == XmlPullParser.START_TAG )
994 {
995 if ( "testResource".equals( parser.getName() ) )
996 {
997 testResources.add( parseResource( parser, strict ) );
998 }
999 else
1000 {
1001 checkUnknownElement( parser, strict );
1002 }
1003 }
1004 build.testResources( testResources );
1005 break;
1006 }
1007 case "directory":
1008 {
1009 build.directory( interpolatedTrimmed( parser.nextText(), "directory" ) );
1010 break;
1011 }
1012 case "finalName":
1013 {
1014 build.finalName( interpolatedTrimmed( parser.nextText(), "finalName" ) );
1015 break;
1016 }
1017 case "filters":
1018 {
1019 List<String> filters = new ArrayList<>();
1020 while ( parser.nextTag() == XmlPullParser.START_TAG )
1021 {
1022 if ( "filter".equals( parser.getName() ) )
1023 {
1024 filters.add( interpolatedTrimmed( parser.nextText(), "filters" ) );
1025 }
1026 else
1027 {
1028 checkUnknownElement( parser, strict );
1029 }
1030 }
1031 build.filters( filters );
1032 break;
1033 }
1034 case "pluginManagement":
1035 {
1036 build.pluginManagement( parsePluginManagement( parser, strict ) );
1037 break;
1038 }
1039 case "plugins":
1040 {
1041 List<Plugin> plugins = new ArrayList<>();
1042 while ( parser.nextTag() == XmlPullParser.START_TAG )
1043 {
1044 if ( "plugin".equals( parser.getName() ) )
1045 {
1046 plugins.add( parsePlugin( parser, strict ) );
1047 }
1048 else
1049 {
1050 checkUnknownElement( parser, strict );
1051 }
1052 }
1053 build.plugins( plugins );
1054 break;
1055 }
1056 default:
1057 {
1058 checkUnknownElement( parser, strict );
1059 break;
1060 }
1061 }
1062 }
1063 return build.build();
1064 }
1065
1066 private CiManagement parseCiManagement( XmlPullParser parser, boolean strict )
1067 throws IOException, XmlPullParserException
1068 {
1069 String tagName = parser.getName();
1070 CiManagement.Builder ciManagement = CiManagement.newBuilder( true );
1071 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1072 {
1073 String name = parser.getAttributeName( i );
1074 String value = parser.getAttributeValue( i );
1075 if ( name.indexOf( ':' ) >= 0 )
1076 {
1077
1078 }
1079 else
1080 {
1081 checkUnknownAttribute( parser, name, tagName, strict );
1082 }
1083 }
1084 Set<String> parsed = new HashSet<>();
1085 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1086 {
1087 String childName = unalias( parser.getName() );
1088 if ( !parsed.add( childName ) )
1089 {
1090 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1091 }
1092 switch ( childName )
1093 {
1094 case "system":
1095 {
1096 ciManagement.system( interpolatedTrimmed( parser.nextText(), "system" ) );
1097 break;
1098 }
1099 case "url":
1100 {
1101 ciManagement.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1102 break;
1103 }
1104 case "notifiers":
1105 {
1106 List<Notifier> notifiers = new ArrayList<>();
1107 while ( parser.nextTag() == XmlPullParser.START_TAG )
1108 {
1109 if ( "notifier".equals( parser.getName() ) )
1110 {
1111 notifiers.add( parseNotifier( parser, strict ) );
1112 }
1113 else
1114 {
1115 checkUnknownElement( parser, strict );
1116 }
1117 }
1118 ciManagement.notifiers( notifiers );
1119 break;
1120 }
1121 default:
1122 {
1123 checkUnknownElement( parser, strict );
1124 break;
1125 }
1126 }
1127 }
1128 return ciManagement.build();
1129 }
1130
1131 private Notifier parseNotifier( XmlPullParser parser, boolean strict )
1132 throws IOException, XmlPullParserException
1133 {
1134 String tagName = parser.getName();
1135 Notifier.Builder notifier = Notifier.newBuilder( true );
1136 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1137 {
1138 String name = parser.getAttributeName( i );
1139 String value = parser.getAttributeValue( i );
1140 if ( name.indexOf( ':' ) >= 0 )
1141 {
1142
1143 }
1144 else
1145 {
1146 checkUnknownAttribute( parser, name, tagName, strict );
1147 }
1148 }
1149 Set<String> parsed = new HashSet<>();
1150 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1151 {
1152 String childName = unalias( parser.getName() );
1153 if ( !parsed.add( childName ) )
1154 {
1155 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1156 }
1157 switch ( childName )
1158 {
1159 case "type":
1160 {
1161 notifier.type( interpolatedTrimmed( parser.nextText(), "type" ) );
1162 break;
1163 }
1164 case "sendOnError":
1165 {
1166 notifier.sendOnError( getBooleanValue( interpolatedTrimmed( parser.nextText(), "sendOnError" ), "sendOnError", parser, true ) );
1167 break;
1168 }
1169 case "sendOnFailure":
1170 {
1171 notifier.sendOnFailure( getBooleanValue( interpolatedTrimmed( parser.nextText(), "sendOnFailure" ), "sendOnFailure", parser, true ) );
1172 break;
1173 }
1174 case "sendOnSuccess":
1175 {
1176 notifier.sendOnSuccess( getBooleanValue( interpolatedTrimmed( parser.nextText(), "sendOnSuccess" ), "sendOnSuccess", parser, true ) );
1177 break;
1178 }
1179 case "sendOnWarning":
1180 {
1181 notifier.sendOnWarning( getBooleanValue( interpolatedTrimmed( parser.nextText(), "sendOnWarning" ), "sendOnWarning", parser, true ) );
1182 break;
1183 }
1184 case "address":
1185 {
1186 notifier.address( interpolatedTrimmed( parser.nextText(), "address" ) );
1187 break;
1188 }
1189 case "configuration":
1190 {
1191 Map<String, String> configuration = new LinkedHashMap<>();
1192 while ( parser.nextTag() == XmlPullParser.START_TAG )
1193 {
1194 String key = parser.getName();
1195 String value = parser.nextText().trim();
1196 configuration.put( key, value );
1197 }
1198 notifier.configuration( configuration );
1199 break;
1200 }
1201 default:
1202 {
1203 checkUnknownElement( parser, strict );
1204 break;
1205 }
1206 }
1207 }
1208 return notifier.build();
1209 }
1210
1211 private Contributor parseContributor( XmlPullParser parser, boolean strict )
1212 throws IOException, XmlPullParserException
1213 {
1214 String tagName = parser.getName();
1215 Contributor.Builder contributor = Contributor.newBuilder( true );
1216 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1217 {
1218 String name = parser.getAttributeName( i );
1219 String value = parser.getAttributeValue( i );
1220 if ( name.indexOf( ':' ) >= 0 )
1221 {
1222
1223 }
1224 else
1225 {
1226 checkUnknownAttribute( parser, name, tagName, strict );
1227 }
1228 }
1229 Set<String> parsed = new HashSet<>();
1230 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1231 {
1232 String childName = unalias( parser.getName() );
1233 if ( !parsed.add( childName ) )
1234 {
1235 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1236 }
1237 switch ( childName )
1238 {
1239 case "name":
1240 {
1241 contributor.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1242 break;
1243 }
1244 case "email":
1245 {
1246 contributor.email( interpolatedTrimmed( parser.nextText(), "email" ) );
1247 break;
1248 }
1249 case "url":
1250 {
1251 contributor.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1252 break;
1253 }
1254 case "organization":
1255 {
1256 contributor.organization( interpolatedTrimmed( parser.nextText(), "organization" ) );
1257 break;
1258 }
1259 case "organizationUrl":
1260 {
1261 contributor.organizationUrl( interpolatedTrimmed( parser.nextText(), "organizationUrl" ) );
1262 break;
1263 }
1264 case "roles":
1265 {
1266 List<String> roles = new ArrayList<>();
1267 while ( parser.nextTag() == XmlPullParser.START_TAG )
1268 {
1269 if ( "role".equals( parser.getName() ) )
1270 {
1271 roles.add( interpolatedTrimmed( parser.nextText(), "roles" ) );
1272 }
1273 else
1274 {
1275 checkUnknownElement( parser, strict );
1276 }
1277 }
1278 contributor.roles( roles );
1279 break;
1280 }
1281 case "timezone":
1282 {
1283 contributor.timezone( interpolatedTrimmed( parser.nextText(), "timezone" ) );
1284 break;
1285 }
1286 case "properties":
1287 {
1288 Map<String, String> properties = new LinkedHashMap<>();
1289 while ( parser.nextTag() == XmlPullParser.START_TAG )
1290 {
1291 String key = parser.getName();
1292 String value = parser.nextText().trim();
1293 properties.put( key, value );
1294 }
1295 contributor.properties( properties );
1296 break;
1297 }
1298 default:
1299 {
1300 checkUnknownElement( parser, strict );
1301 break;
1302 }
1303 }
1304 }
1305 return contributor.build();
1306 }
1307
1308 private Dependency parseDependency( XmlPullParser parser, boolean strict )
1309 throws IOException, XmlPullParserException
1310 {
1311 String tagName = parser.getName();
1312 Dependency.Builder dependency = Dependency.newBuilder( true );
1313 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1314 {
1315 String name = parser.getAttributeName( i );
1316 String value = parser.getAttributeValue( i );
1317 if ( name.indexOf( ':' ) >= 0 )
1318 {
1319
1320 }
1321 else
1322 {
1323 checkUnknownAttribute( parser, name, tagName, strict );
1324 }
1325 }
1326 Set<String> parsed = new HashSet<>();
1327 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1328 {
1329 String childName = unalias( parser.getName() );
1330 if ( !parsed.add( childName ) )
1331 {
1332 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1333 }
1334 switch ( childName )
1335 {
1336 case "groupId":
1337 {
1338 dependency.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1339 break;
1340 }
1341 case "artifactId":
1342 {
1343 dependency.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1344 break;
1345 }
1346 case "version":
1347 {
1348 dependency.version( interpolatedTrimmed( parser.nextText(), "version" ) );
1349 break;
1350 }
1351 case "type":
1352 {
1353 dependency.type( interpolatedTrimmed( parser.nextText(), "type" ) );
1354 break;
1355 }
1356 case "classifier":
1357 {
1358 dependency.classifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
1359 break;
1360 }
1361 case "scope":
1362 {
1363 dependency.scope( interpolatedTrimmed( parser.nextText(), "scope" ) );
1364 break;
1365 }
1366 case "systemPath":
1367 {
1368 dependency.systemPath( interpolatedTrimmed( parser.nextText(), "systemPath" ) );
1369 break;
1370 }
1371 case "exclusions":
1372 {
1373 List<Exclusion> exclusions = new ArrayList<>();
1374 while ( parser.nextTag() == XmlPullParser.START_TAG )
1375 {
1376 if ( "exclusion".equals( parser.getName() ) )
1377 {
1378 exclusions.add( parseExclusion( parser, strict ) );
1379 }
1380 else
1381 {
1382 checkUnknownElement( parser, strict );
1383 }
1384 }
1385 dependency.exclusions( exclusions );
1386 break;
1387 }
1388 case "optional":
1389 {
1390 dependency.optional( interpolatedTrimmed( parser.nextText(), "optional" ) );
1391 break;
1392 }
1393 default:
1394 {
1395 checkUnknownElement( parser, strict );
1396 break;
1397 }
1398 }
1399 }
1400 return dependency.build();
1401 }
1402
1403 private Developer parseDeveloper( XmlPullParser parser, boolean strict )
1404 throws IOException, XmlPullParserException
1405 {
1406 String tagName = parser.getName();
1407 Developer.Builder developer = Developer.newBuilder( true );
1408 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1409 {
1410 String name = parser.getAttributeName( i );
1411 String value = parser.getAttributeValue( i );
1412 if ( name.indexOf( ':' ) >= 0 )
1413 {
1414
1415 }
1416 else
1417 {
1418 checkUnknownAttribute( parser, name, tagName, strict );
1419 }
1420 }
1421 Set<String> parsed = new HashSet<>();
1422 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1423 {
1424 String childName = unalias( parser.getName() );
1425 if ( !parsed.add( childName ) )
1426 {
1427 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1428 }
1429 switch ( childName )
1430 {
1431 case "id":
1432 {
1433 developer.id( interpolatedTrimmed( parser.nextText(), "id" ) );
1434 break;
1435 }
1436 case "name":
1437 {
1438 developer.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1439 break;
1440 }
1441 case "email":
1442 {
1443 developer.email( interpolatedTrimmed( parser.nextText(), "email" ) );
1444 break;
1445 }
1446 case "url":
1447 {
1448 developer.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1449 break;
1450 }
1451 case "organization":
1452 {
1453 developer.organization( interpolatedTrimmed( parser.nextText(), "organization" ) );
1454 break;
1455 }
1456 case "organizationUrl":
1457 {
1458 developer.organizationUrl( interpolatedTrimmed( parser.nextText(), "organizationUrl" ) );
1459 break;
1460 }
1461 case "roles":
1462 {
1463 List<String> roles = new ArrayList<>();
1464 while ( parser.nextTag() == XmlPullParser.START_TAG )
1465 {
1466 if ( "role".equals( parser.getName() ) )
1467 {
1468 roles.add( interpolatedTrimmed( parser.nextText(), "roles" ) );
1469 }
1470 else
1471 {
1472 checkUnknownElement( parser, strict );
1473 }
1474 }
1475 developer.roles( roles );
1476 break;
1477 }
1478 case "timezone":
1479 {
1480 developer.timezone( interpolatedTrimmed( parser.nextText(), "timezone" ) );
1481 break;
1482 }
1483 case "properties":
1484 {
1485 Map<String, String> properties = new LinkedHashMap<>();
1486 while ( parser.nextTag() == XmlPullParser.START_TAG )
1487 {
1488 String key = parser.getName();
1489 String value = parser.nextText().trim();
1490 properties.put( key, value );
1491 }
1492 developer.properties( properties );
1493 break;
1494 }
1495 default:
1496 {
1497 checkUnknownElement( parser, strict );
1498 break;
1499 }
1500 }
1501 }
1502 return developer.build();
1503 }
1504
1505 private Exclusion parseExclusion( XmlPullParser parser, boolean strict )
1506 throws IOException, XmlPullParserException
1507 {
1508 String tagName = parser.getName();
1509 Exclusion.Builder exclusion = Exclusion.newBuilder( true );
1510 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1511 {
1512 String name = parser.getAttributeName( i );
1513 String value = parser.getAttributeValue( i );
1514 if ( name.indexOf( ':' ) >= 0 )
1515 {
1516
1517 }
1518 else
1519 {
1520 checkUnknownAttribute( parser, name, tagName, strict );
1521 }
1522 }
1523 Set<String> parsed = new HashSet<>();
1524 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1525 {
1526 String childName = unalias( parser.getName() );
1527 if ( !parsed.add( childName ) )
1528 {
1529 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1530 }
1531 switch ( childName )
1532 {
1533 case "groupId":
1534 {
1535 exclusion.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1536 break;
1537 }
1538 case "artifactId":
1539 {
1540 exclusion.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1541 break;
1542 }
1543 default:
1544 {
1545 checkUnknownElement( parser, strict );
1546 break;
1547 }
1548 }
1549 }
1550 return exclusion.build();
1551 }
1552
1553 private IssueManagement parseIssueManagement( XmlPullParser parser, boolean strict )
1554 throws IOException, XmlPullParserException
1555 {
1556 String tagName = parser.getName();
1557 IssueManagement.Builder issueManagement = IssueManagement.newBuilder( true );
1558 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1559 {
1560 String name = parser.getAttributeName( i );
1561 String value = parser.getAttributeValue( i );
1562 if ( name.indexOf( ':' ) >= 0 )
1563 {
1564
1565 }
1566 else
1567 {
1568 checkUnknownAttribute( parser, name, tagName, strict );
1569 }
1570 }
1571 Set<String> parsed = new HashSet<>();
1572 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1573 {
1574 String childName = unalias( parser.getName() );
1575 if ( !parsed.add( childName ) )
1576 {
1577 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1578 }
1579 switch ( childName )
1580 {
1581 case "system":
1582 {
1583 issueManagement.system( interpolatedTrimmed( parser.nextText(), "system" ) );
1584 break;
1585 }
1586 case "url":
1587 {
1588 issueManagement.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1589 break;
1590 }
1591 default:
1592 {
1593 checkUnknownElement( parser, strict );
1594 break;
1595 }
1596 }
1597 }
1598 return issueManagement.build();
1599 }
1600
1601 private DistributionManagement parseDistributionManagement( XmlPullParser parser, boolean strict )
1602 throws IOException, XmlPullParserException
1603 {
1604 String tagName = parser.getName();
1605 DistributionManagement.Builder distributionManagement = DistributionManagement.newBuilder( true );
1606 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1607 {
1608 String name = parser.getAttributeName( i );
1609 String value = parser.getAttributeValue( i );
1610 if ( name.indexOf( ':' ) >= 0 )
1611 {
1612
1613 }
1614 else
1615 {
1616 checkUnknownAttribute( parser, name, tagName, strict );
1617 }
1618 }
1619 Set<String> parsed = new HashSet<>();
1620 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1621 {
1622 String childName = unalias( parser.getName() );
1623 if ( !parsed.add( childName ) )
1624 {
1625 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1626 }
1627 switch ( childName )
1628 {
1629 case "repository":
1630 {
1631 distributionManagement.repository( parseDeploymentRepository( parser, strict ) );
1632 break;
1633 }
1634 case "snapshotRepository":
1635 {
1636 distributionManagement.snapshotRepository( parseDeploymentRepository( parser, strict ) );
1637 break;
1638 }
1639 case "site":
1640 {
1641 distributionManagement.site( parseSite( parser, strict ) );
1642 break;
1643 }
1644 case "downloadUrl":
1645 {
1646 distributionManagement.downloadUrl( interpolatedTrimmed( parser.nextText(), "downloadUrl" ) );
1647 break;
1648 }
1649 case "relocation":
1650 {
1651 distributionManagement.relocation( parseRelocation( parser, strict ) );
1652 break;
1653 }
1654 case "status":
1655 {
1656 distributionManagement.status( interpolatedTrimmed( parser.nextText(), "status" ) );
1657 break;
1658 }
1659 default:
1660 {
1661 checkUnknownElement( parser, strict );
1662 break;
1663 }
1664 }
1665 }
1666 return distributionManagement.build();
1667 }
1668
1669 private License parseLicense( XmlPullParser parser, boolean strict )
1670 throws IOException, XmlPullParserException
1671 {
1672 String tagName = parser.getName();
1673 License.Builder license = License.newBuilder( true );
1674 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1675 {
1676 String name = parser.getAttributeName( i );
1677 String value = parser.getAttributeValue( i );
1678 if ( name.indexOf( ':' ) >= 0 )
1679 {
1680
1681 }
1682 else
1683 {
1684 checkUnknownAttribute( parser, name, tagName, strict );
1685 }
1686 }
1687 Set<String> parsed = new HashSet<>();
1688 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1689 {
1690 String childName = unalias( parser.getName() );
1691 if ( !parsed.add( childName ) )
1692 {
1693 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1694 }
1695 switch ( childName )
1696 {
1697 case "name":
1698 {
1699 license.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1700 break;
1701 }
1702 case "url":
1703 {
1704 license.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1705 break;
1706 }
1707 case "distribution":
1708 {
1709 license.distribution( interpolatedTrimmed( parser.nextText(), "distribution" ) );
1710 break;
1711 }
1712 case "comments":
1713 {
1714 license.comments( interpolatedTrimmed( parser.nextText(), "comments" ) );
1715 break;
1716 }
1717 default:
1718 {
1719 checkUnknownElement( parser, strict );
1720 break;
1721 }
1722 }
1723 }
1724 return license.build();
1725 }
1726
1727 private MailingList parseMailingList( XmlPullParser parser, boolean strict )
1728 throws IOException, XmlPullParserException
1729 {
1730 String tagName = parser.getName();
1731 MailingList.Builder mailingList = MailingList.newBuilder( true );
1732 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1733 {
1734 String name = parser.getAttributeName( i );
1735 String value = parser.getAttributeValue( i );
1736 if ( name.indexOf( ':' ) >= 0 )
1737 {
1738
1739 }
1740 else
1741 {
1742 checkUnknownAttribute( parser, name, tagName, strict );
1743 }
1744 }
1745 Set<String> parsed = new HashSet<>();
1746 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1747 {
1748 String childName = unalias( parser.getName() );
1749 if ( !parsed.add( childName ) )
1750 {
1751 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1752 }
1753 switch ( childName )
1754 {
1755 case "name":
1756 {
1757 mailingList.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1758 break;
1759 }
1760 case "subscribe":
1761 {
1762 mailingList.subscribe( interpolatedTrimmed( parser.nextText(), "subscribe" ) );
1763 break;
1764 }
1765 case "unsubscribe":
1766 {
1767 mailingList.unsubscribe( interpolatedTrimmed( parser.nextText(), "unsubscribe" ) );
1768 break;
1769 }
1770 case "post":
1771 {
1772 mailingList.post( interpolatedTrimmed( parser.nextText(), "post" ) );
1773 break;
1774 }
1775 case "archive":
1776 {
1777 mailingList.archive( interpolatedTrimmed( parser.nextText(), "archive" ) );
1778 break;
1779 }
1780 case "otherArchives":
1781 {
1782 List<String> otherArchives = new ArrayList<>();
1783 while ( parser.nextTag() == XmlPullParser.START_TAG )
1784 {
1785 if ( "otherArchive".equals( parser.getName() ) )
1786 {
1787 otherArchives.add( interpolatedTrimmed( parser.nextText(), "otherArchives" ) );
1788 }
1789 else
1790 {
1791 checkUnknownElement( parser, strict );
1792 }
1793 }
1794 mailingList.otherArchives( otherArchives );
1795 break;
1796 }
1797 default:
1798 {
1799 checkUnknownElement( parser, strict );
1800 break;
1801 }
1802 }
1803 }
1804 return mailingList.build();
1805 }
1806
1807 private Organization parseOrganization( XmlPullParser parser, boolean strict )
1808 throws IOException, XmlPullParserException
1809 {
1810 String tagName = parser.getName();
1811 Organization.Builder organization = Organization.newBuilder( true );
1812 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1813 {
1814 String name = parser.getAttributeName( i );
1815 String value = parser.getAttributeValue( i );
1816 if ( name.indexOf( ':' ) >= 0 )
1817 {
1818
1819 }
1820 else
1821 {
1822 checkUnknownAttribute( parser, name, tagName, strict );
1823 }
1824 }
1825 Set<String> parsed = new HashSet<>();
1826 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1827 {
1828 String childName = unalias( parser.getName() );
1829 if ( !parsed.add( childName ) )
1830 {
1831 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1832 }
1833 switch ( childName )
1834 {
1835 case "name":
1836 {
1837 organization.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1838 break;
1839 }
1840 case "url":
1841 {
1842 organization.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1843 break;
1844 }
1845 default:
1846 {
1847 checkUnknownElement( parser, strict );
1848 break;
1849 }
1850 }
1851 }
1852 return organization.build();
1853 }
1854
1855 private PatternSet parsePatternSet( XmlPullParser parser, boolean strict )
1856 throws IOException, XmlPullParserException
1857 {
1858 String tagName = parser.getName();
1859 PatternSet.Builder patternSet = PatternSet.newBuilder( true );
1860 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1861 {
1862 String name = parser.getAttributeName( i );
1863 String value = parser.getAttributeValue( i );
1864 if ( name.indexOf( ':' ) >= 0 )
1865 {
1866
1867 }
1868 else
1869 {
1870 checkUnknownAttribute( parser, name, tagName, strict );
1871 }
1872 }
1873 Set<String> parsed = new HashSet<>();
1874 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1875 {
1876 String childName = unalias( parser.getName() );
1877 if ( !parsed.add( childName ) )
1878 {
1879 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1880 }
1881 switch ( childName )
1882 {
1883 case "includes":
1884 {
1885 List<String> includes = new ArrayList<>();
1886 while ( parser.nextTag() == XmlPullParser.START_TAG )
1887 {
1888 if ( "include".equals( parser.getName() ) )
1889 {
1890 includes.add( interpolatedTrimmed( parser.nextText(), "includes" ) );
1891 }
1892 else
1893 {
1894 checkUnknownElement( parser, strict );
1895 }
1896 }
1897 patternSet.includes( includes );
1898 break;
1899 }
1900 case "excludes":
1901 {
1902 List<String> excludes = new ArrayList<>();
1903 while ( parser.nextTag() == XmlPullParser.START_TAG )
1904 {
1905 if ( "exclude".equals( parser.getName() ) )
1906 {
1907 excludes.add( interpolatedTrimmed( parser.nextText(), "excludes" ) );
1908 }
1909 else
1910 {
1911 checkUnknownElement( parser, strict );
1912 }
1913 }
1914 patternSet.excludes( excludes );
1915 break;
1916 }
1917 default:
1918 {
1919 checkUnknownElement( parser, strict );
1920 break;
1921 }
1922 }
1923 }
1924 return patternSet.build();
1925 }
1926
1927 private Parent parseParent( XmlPullParser parser, boolean strict )
1928 throws IOException, XmlPullParserException
1929 {
1930 String tagName = parser.getName();
1931 Parent.Builder parent = Parent.newBuilder( true );
1932 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1933 {
1934 String name = parser.getAttributeName( i );
1935 String value = parser.getAttributeValue( i );
1936 if ( name.indexOf( ':' ) >= 0 )
1937 {
1938
1939 }
1940 else
1941 {
1942 checkUnknownAttribute( parser, name, tagName, strict );
1943 }
1944 }
1945 Set<String> parsed = new HashSet<>();
1946 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1947 {
1948 String childName = unalias( parser.getName() );
1949 if ( !parsed.add( childName ) )
1950 {
1951 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
1952 }
1953 switch ( childName )
1954 {
1955 case "groupId":
1956 {
1957 parent.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1958 break;
1959 }
1960 case "artifactId":
1961 {
1962 parent.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1963 break;
1964 }
1965 case "version":
1966 {
1967 parent.version( interpolatedTrimmed( parser.nextText(), "version" ) );
1968 break;
1969 }
1970 case "relativePath":
1971 {
1972 parent.relativePath( interpolatedTrimmed( parser.nextText(), "relativePath" ) );
1973 break;
1974 }
1975 default:
1976 {
1977 checkUnknownElement( parser, strict );
1978 break;
1979 }
1980 }
1981 }
1982 return parent.build();
1983 }
1984
1985 private Scm parseScm( XmlPullParser parser, boolean strict )
1986 throws IOException, XmlPullParserException
1987 {
1988 String tagName = parser.getName();
1989 Scm.Builder scm = Scm.newBuilder( true );
1990 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1991 {
1992 String name = parser.getAttributeName( i );
1993 String value = parser.getAttributeValue( i );
1994 if ( name.indexOf( ':' ) >= 0 )
1995 {
1996
1997 }
1998 else if ( "child.scm.connection.inherit.append.path".equals( name ) )
1999 {
2000 scm.childScmConnectionInheritAppendPath( interpolatedTrimmed( value, "child.scm.connection.inherit.append.path" ) );
2001 }
2002 else if ( "child.scm.developerConnection.inherit.append.path".equals( name ) )
2003 {
2004 scm.childScmDeveloperConnectionInheritAppendPath( interpolatedTrimmed( value, "child.scm.developerConnection.inherit.append.path" ) );
2005 }
2006 else if ( "child.scm.url.inherit.append.path".equals( name ) )
2007 {
2008 scm.childScmUrlInheritAppendPath( interpolatedTrimmed( value, "child.scm.url.inherit.append.path" ) );
2009 }
2010 else
2011 {
2012 checkUnknownAttribute( parser, name, tagName, strict );
2013 }
2014 }
2015 Set<String> parsed = new HashSet<>();
2016 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2017 {
2018 String childName = unalias( parser.getName() );
2019 if ( !parsed.add( childName ) )
2020 {
2021 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2022 }
2023 switch ( childName )
2024 {
2025 case "connection":
2026 {
2027 scm.connection( interpolatedTrimmed( parser.nextText(), "connection" ) );
2028 break;
2029 }
2030 case "developerConnection":
2031 {
2032 scm.developerConnection( interpolatedTrimmed( parser.nextText(), "developerConnection" ) );
2033 break;
2034 }
2035 case "tag":
2036 {
2037 scm.tag( interpolatedTrimmed( parser.nextText(), "tag" ) );
2038 break;
2039 }
2040 case "url":
2041 {
2042 scm.url( interpolatedTrimmed( parser.nextText(), "url" ) );
2043 break;
2044 }
2045 default:
2046 {
2047 checkUnknownElement( parser, strict );
2048 break;
2049 }
2050 }
2051 }
2052 return scm.build();
2053 }
2054
2055 private FileSet parseFileSet( XmlPullParser parser, boolean strict )
2056 throws IOException, XmlPullParserException
2057 {
2058 String tagName = parser.getName();
2059 FileSet.Builder fileSet = FileSet.newBuilder( true );
2060 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2061 {
2062 String name = parser.getAttributeName( i );
2063 String value = parser.getAttributeValue( i );
2064 if ( name.indexOf( ':' ) >= 0 )
2065 {
2066
2067 }
2068 else
2069 {
2070 checkUnknownAttribute( parser, name, tagName, strict );
2071 }
2072 }
2073 Set<String> parsed = new HashSet<>();
2074 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2075 {
2076 String childName = unalias( parser.getName() );
2077 if ( !parsed.add( childName ) )
2078 {
2079 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2080 }
2081 switch ( childName )
2082 {
2083 case "directory":
2084 {
2085 fileSet.directory( interpolatedTrimmed( parser.nextText(), "directory" ) );
2086 break;
2087 }
2088 case "includes":
2089 {
2090 List<String> includes = new ArrayList<>();
2091 while ( parser.nextTag() == XmlPullParser.START_TAG )
2092 {
2093 if ( "include".equals( parser.getName() ) )
2094 {
2095 includes.add( interpolatedTrimmed( parser.nextText(), "includes" ) );
2096 }
2097 else
2098 {
2099 checkUnknownElement( parser, strict );
2100 }
2101 }
2102 fileSet.includes( includes );
2103 break;
2104 }
2105 case "excludes":
2106 {
2107 List<String> excludes = new ArrayList<>();
2108 while ( parser.nextTag() == XmlPullParser.START_TAG )
2109 {
2110 if ( "exclude".equals( parser.getName() ) )
2111 {
2112 excludes.add( interpolatedTrimmed( parser.nextText(), "excludes" ) );
2113 }
2114 else
2115 {
2116 checkUnknownElement( parser, strict );
2117 }
2118 }
2119 fileSet.excludes( excludes );
2120 break;
2121 }
2122 default:
2123 {
2124 checkUnknownElement( parser, strict );
2125 break;
2126 }
2127 }
2128 }
2129 return fileSet.build();
2130 }
2131
2132 private Resource parseResource( XmlPullParser parser, boolean strict )
2133 throws IOException, XmlPullParserException
2134 {
2135 String tagName = parser.getName();
2136 Resource.Builder resource = Resource.newBuilder( true );
2137 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2138 {
2139 String name = parser.getAttributeName( i );
2140 String value = parser.getAttributeValue( i );
2141 if ( name.indexOf( ':' ) >= 0 )
2142 {
2143
2144 }
2145 else
2146 {
2147 checkUnknownAttribute( parser, name, tagName, strict );
2148 }
2149 }
2150 Set<String> parsed = new HashSet<>();
2151 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2152 {
2153 String childName = unalias( parser.getName() );
2154 if ( !parsed.add( childName ) )
2155 {
2156 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2157 }
2158 switch ( childName )
2159 {
2160 case "targetPath":
2161 {
2162 resource.targetPath( interpolatedTrimmed( parser.nextText(), "targetPath" ) );
2163 break;
2164 }
2165 case "filtering":
2166 {
2167 resource.filtering( interpolatedTrimmed( parser.nextText(), "filtering" ) );
2168 break;
2169 }
2170 case "directory":
2171 {
2172 resource.directory( interpolatedTrimmed( parser.nextText(), "directory" ) );
2173 break;
2174 }
2175 case "includes":
2176 {
2177 List<String> includes = new ArrayList<>();
2178 while ( parser.nextTag() == XmlPullParser.START_TAG )
2179 {
2180 if ( "include".equals( parser.getName() ) )
2181 {
2182 includes.add( interpolatedTrimmed( parser.nextText(), "includes" ) );
2183 }
2184 else
2185 {
2186 checkUnknownElement( parser, strict );
2187 }
2188 }
2189 resource.includes( includes );
2190 break;
2191 }
2192 case "excludes":
2193 {
2194 List<String> excludes = new ArrayList<>();
2195 while ( parser.nextTag() == XmlPullParser.START_TAG )
2196 {
2197 if ( "exclude".equals( parser.getName() ) )
2198 {
2199 excludes.add( interpolatedTrimmed( parser.nextText(), "excludes" ) );
2200 }
2201 else
2202 {
2203 checkUnknownElement( parser, strict );
2204 }
2205 }
2206 resource.excludes( excludes );
2207 break;
2208 }
2209 default:
2210 {
2211 checkUnknownElement( parser, strict );
2212 break;
2213 }
2214 }
2215 }
2216 return resource.build();
2217 }
2218
2219 private RepositoryBase parseRepositoryBase( XmlPullParser parser, boolean strict )
2220 throws IOException, XmlPullParserException
2221 {
2222 String tagName = parser.getName();
2223 RepositoryBase.Builder repositoryBase = RepositoryBase.newBuilder( true );
2224 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2225 {
2226 String name = parser.getAttributeName( i );
2227 String value = parser.getAttributeValue( i );
2228 if ( name.indexOf( ':' ) >= 0 )
2229 {
2230
2231 }
2232 else
2233 {
2234 checkUnknownAttribute( parser, name, tagName, strict );
2235 }
2236 }
2237 Set<String> parsed = new HashSet<>();
2238 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2239 {
2240 String childName = unalias( parser.getName() );
2241 if ( !parsed.add( childName ) )
2242 {
2243 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2244 }
2245 switch ( childName )
2246 {
2247 case "id":
2248 {
2249 repositoryBase.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2250 break;
2251 }
2252 case "name":
2253 {
2254 repositoryBase.name( interpolatedTrimmed( parser.nextText(), "name" ) );
2255 break;
2256 }
2257 case "url":
2258 {
2259 repositoryBase.url( interpolatedTrimmed( parser.nextText(), "url" ) );
2260 break;
2261 }
2262 case "layout":
2263 {
2264 repositoryBase.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
2265 break;
2266 }
2267 default:
2268 {
2269 checkUnknownElement( parser, strict );
2270 break;
2271 }
2272 }
2273 }
2274 return repositoryBase.build();
2275 }
2276
2277 private Repository parseRepository( XmlPullParser parser, boolean strict )
2278 throws IOException, XmlPullParserException
2279 {
2280 String tagName = parser.getName();
2281 Repository.Builder repository = Repository.newBuilder( true );
2282 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2283 {
2284 String name = parser.getAttributeName( i );
2285 String value = parser.getAttributeValue( i );
2286 if ( name.indexOf( ':' ) >= 0 )
2287 {
2288
2289 }
2290 else
2291 {
2292 checkUnknownAttribute( parser, name, tagName, strict );
2293 }
2294 }
2295 Set<String> parsed = new HashSet<>();
2296 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2297 {
2298 String childName = unalias( parser.getName() );
2299 if ( !parsed.add( childName ) )
2300 {
2301 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2302 }
2303 switch ( childName )
2304 {
2305 case "releases":
2306 {
2307 repository.releases( parseRepositoryPolicy( parser, strict ) );
2308 break;
2309 }
2310 case "snapshots":
2311 {
2312 repository.snapshots( parseRepositoryPolicy( parser, strict ) );
2313 break;
2314 }
2315 case "id":
2316 {
2317 repository.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2318 break;
2319 }
2320 case "name":
2321 {
2322 repository.name( interpolatedTrimmed( parser.nextText(), "name" ) );
2323 break;
2324 }
2325 case "url":
2326 {
2327 repository.url( interpolatedTrimmed( parser.nextText(), "url" ) );
2328 break;
2329 }
2330 case "layout":
2331 {
2332 repository.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
2333 break;
2334 }
2335 default:
2336 {
2337 checkUnknownElement( parser, strict );
2338 break;
2339 }
2340 }
2341 }
2342 return repository.build();
2343 }
2344
2345 private DeploymentRepository parseDeploymentRepository( XmlPullParser parser, boolean strict )
2346 throws IOException, XmlPullParserException
2347 {
2348 String tagName = parser.getName();
2349 DeploymentRepository.Builder deploymentRepository = DeploymentRepository.newBuilder( true );
2350 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2351 {
2352 String name = parser.getAttributeName( i );
2353 String value = parser.getAttributeValue( i );
2354 if ( name.indexOf( ':' ) >= 0 )
2355 {
2356
2357 }
2358 else
2359 {
2360 checkUnknownAttribute( parser, name, tagName, strict );
2361 }
2362 }
2363 Set<String> parsed = new HashSet<>();
2364 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2365 {
2366 String childName = unalias( parser.getName() );
2367 if ( !parsed.add( childName ) )
2368 {
2369 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2370 }
2371 switch ( childName )
2372 {
2373 case "uniqueVersion":
2374 {
2375 deploymentRepository.uniqueVersion( getBooleanValue( interpolatedTrimmed( parser.nextText(), "uniqueVersion" ), "uniqueVersion", parser, true ) );
2376 break;
2377 }
2378 case "releases":
2379 {
2380 deploymentRepository.releases( parseRepositoryPolicy( parser, strict ) );
2381 break;
2382 }
2383 case "snapshots":
2384 {
2385 deploymentRepository.snapshots( parseRepositoryPolicy( parser, strict ) );
2386 break;
2387 }
2388 case "id":
2389 {
2390 deploymentRepository.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2391 break;
2392 }
2393 case "name":
2394 {
2395 deploymentRepository.name( interpolatedTrimmed( parser.nextText(), "name" ) );
2396 break;
2397 }
2398 case "url":
2399 {
2400 deploymentRepository.url( interpolatedTrimmed( parser.nextText(), "url" ) );
2401 break;
2402 }
2403 case "layout":
2404 {
2405 deploymentRepository.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
2406 break;
2407 }
2408 default:
2409 {
2410 checkUnknownElement( parser, strict );
2411 break;
2412 }
2413 }
2414 }
2415 return deploymentRepository.build();
2416 }
2417
2418 private RepositoryPolicy parseRepositoryPolicy( XmlPullParser parser, boolean strict )
2419 throws IOException, XmlPullParserException
2420 {
2421 String tagName = parser.getName();
2422 RepositoryPolicy.Builder repositoryPolicy = RepositoryPolicy.newBuilder( true );
2423 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2424 {
2425 String name = parser.getAttributeName( i );
2426 String value = parser.getAttributeValue( i );
2427 if ( name.indexOf( ':' ) >= 0 )
2428 {
2429
2430 }
2431 else
2432 {
2433 checkUnknownAttribute( parser, name, tagName, strict );
2434 }
2435 }
2436 Set<String> parsed = new HashSet<>();
2437 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2438 {
2439 String childName = unalias( parser.getName() );
2440 if ( !parsed.add( childName ) )
2441 {
2442 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2443 }
2444 switch ( childName )
2445 {
2446 case "enabled":
2447 {
2448 repositoryPolicy.enabled( interpolatedTrimmed( parser.nextText(), "enabled" ) );
2449 break;
2450 }
2451 case "updatePolicy":
2452 {
2453 repositoryPolicy.updatePolicy( interpolatedTrimmed( parser.nextText(), "updatePolicy" ) );
2454 break;
2455 }
2456 case "checksumPolicy":
2457 {
2458 repositoryPolicy.checksumPolicy( interpolatedTrimmed( parser.nextText(), "checksumPolicy" ) );
2459 break;
2460 }
2461 default:
2462 {
2463 checkUnknownElement( parser, strict );
2464 break;
2465 }
2466 }
2467 }
2468 return repositoryPolicy.build();
2469 }
2470
2471 private Site parseSite( XmlPullParser parser, boolean strict )
2472 throws IOException, XmlPullParserException
2473 {
2474 String tagName = parser.getName();
2475 Site.Builder site = Site.newBuilder( true );
2476 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2477 {
2478 String name = parser.getAttributeName( i );
2479 String value = parser.getAttributeValue( i );
2480 if ( name.indexOf( ':' ) >= 0 )
2481 {
2482
2483 }
2484 else if ( "child.site.url.inherit.append.path".equals( name ) )
2485 {
2486 site.childSiteUrlInheritAppendPath( interpolatedTrimmed( value, "child.site.url.inherit.append.path" ) );
2487 }
2488 else
2489 {
2490 checkUnknownAttribute( parser, name, tagName, strict );
2491 }
2492 }
2493 Set<String> parsed = new HashSet<>();
2494 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2495 {
2496 String childName = unalias( parser.getName() );
2497 if ( !parsed.add( childName ) )
2498 {
2499 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2500 }
2501 switch ( childName )
2502 {
2503 case "id":
2504 {
2505 site.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2506 break;
2507 }
2508 case "name":
2509 {
2510 site.name( interpolatedTrimmed( parser.nextText(), "name" ) );
2511 break;
2512 }
2513 case "url":
2514 {
2515 site.url( interpolatedTrimmed( parser.nextText(), "url" ) );
2516 break;
2517 }
2518 default:
2519 {
2520 checkUnknownElement( parser, strict );
2521 break;
2522 }
2523 }
2524 }
2525 return site.build();
2526 }
2527
2528 private ConfigurationContainer parseConfigurationContainer( XmlPullParser parser, boolean strict )
2529 throws IOException, XmlPullParserException
2530 {
2531 String tagName = parser.getName();
2532 ConfigurationContainer.Builder configurationContainer = ConfigurationContainer.newBuilder( true );
2533 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2534 {
2535 String name = parser.getAttributeName( i );
2536 String value = parser.getAttributeValue( i );
2537 if ( name.indexOf( ':' ) >= 0 )
2538 {
2539
2540 }
2541 else
2542 {
2543 checkUnknownAttribute( parser, name, tagName, strict );
2544 }
2545 }
2546 Set<String> parsed = new HashSet<>();
2547 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2548 {
2549 String childName = unalias( parser.getName() );
2550 if ( !parsed.add( childName ) )
2551 {
2552 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2553 }
2554 switch ( childName )
2555 {
2556 case "inherited":
2557 {
2558 configurationContainer.inherited( interpolatedTrimmed( parser.nextText(), "inherited" ) );
2559 break;
2560 }
2561 case "configuration":
2562 {
2563 configurationContainer.configuration( XmlNodeBuilder.build( parser, true ) );
2564 break;
2565 }
2566 default:
2567 {
2568 checkUnknownElement( parser, strict );
2569 break;
2570 }
2571 }
2572 }
2573 return configurationContainer.build();
2574 }
2575
2576 private Plugin parsePlugin( XmlPullParser parser, boolean strict )
2577 throws IOException, XmlPullParserException
2578 {
2579 String tagName = parser.getName();
2580 Plugin.Builder plugin = Plugin.newBuilder( true );
2581 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2582 {
2583 String name = parser.getAttributeName( i );
2584 String value = parser.getAttributeValue( i );
2585 if ( name.indexOf( ':' ) >= 0 )
2586 {
2587
2588 }
2589 else
2590 {
2591 checkUnknownAttribute( parser, name, tagName, strict );
2592 }
2593 }
2594 Set<String> parsed = new HashSet<>();
2595 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2596 {
2597 String childName = unalias( parser.getName() );
2598 if ( !parsed.add( childName ) )
2599 {
2600 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2601 }
2602 switch ( childName )
2603 {
2604 case "groupId":
2605 {
2606 plugin.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
2607 break;
2608 }
2609 case "artifactId":
2610 {
2611 plugin.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
2612 break;
2613 }
2614 case "version":
2615 {
2616 plugin.version( interpolatedTrimmed( parser.nextText(), "version" ) );
2617 break;
2618 }
2619 case "extensions":
2620 {
2621 plugin.extensions( interpolatedTrimmed( parser.nextText(), "extensions" ) );
2622 break;
2623 }
2624 case "executions":
2625 {
2626 List<PluginExecution> executions = new ArrayList<>();
2627 while ( parser.nextTag() == XmlPullParser.START_TAG )
2628 {
2629 if ( "execution".equals( parser.getName() ) )
2630 {
2631 executions.add( parsePluginExecution( parser, strict ) );
2632 }
2633 else
2634 {
2635 checkUnknownElement( parser, strict );
2636 }
2637 }
2638 plugin.executions( executions );
2639 break;
2640 }
2641 case "dependencies":
2642 {
2643 List<Dependency> dependencies = new ArrayList<>();
2644 while ( parser.nextTag() == XmlPullParser.START_TAG )
2645 {
2646 if ( "dependency".equals( parser.getName() ) )
2647 {
2648 dependencies.add( parseDependency( parser, strict ) );
2649 }
2650 else
2651 {
2652 checkUnknownElement( parser, strict );
2653 }
2654 }
2655 plugin.dependencies( dependencies );
2656 break;
2657 }
2658 case "inherited":
2659 {
2660 plugin.inherited( interpolatedTrimmed( parser.nextText(), "inherited" ) );
2661 break;
2662 }
2663 case "configuration":
2664 {
2665 plugin.configuration( XmlNodeBuilder.build( parser, true ) );
2666 break;
2667 }
2668 default:
2669 {
2670 checkUnknownElement( parser, strict );
2671 break;
2672 }
2673 }
2674 }
2675 return plugin.build();
2676 }
2677
2678 private PluginExecution parsePluginExecution( XmlPullParser parser, boolean strict )
2679 throws IOException, XmlPullParserException
2680 {
2681 String tagName = parser.getName();
2682 PluginExecution.Builder pluginExecution = PluginExecution.newBuilder( true );
2683 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2684 {
2685 String name = parser.getAttributeName( i );
2686 String value = parser.getAttributeValue( i );
2687 if ( name.indexOf( ':' ) >= 0 )
2688 {
2689
2690 }
2691 else
2692 {
2693 checkUnknownAttribute( parser, name, tagName, strict );
2694 }
2695 }
2696 Set<String> parsed = new HashSet<>();
2697 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2698 {
2699 String childName = unalias( parser.getName() );
2700 if ( !parsed.add( childName ) )
2701 {
2702 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2703 }
2704 switch ( childName )
2705 {
2706 case "id":
2707 {
2708 pluginExecution.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2709 break;
2710 }
2711 case "phase":
2712 {
2713 pluginExecution.phase( interpolatedTrimmed( parser.nextText(), "phase" ) );
2714 break;
2715 }
2716 case "goals":
2717 {
2718 List<String> goals = new ArrayList<>();
2719 while ( parser.nextTag() == XmlPullParser.START_TAG )
2720 {
2721 if ( "goal".equals( parser.getName() ) )
2722 {
2723 goals.add( interpolatedTrimmed( parser.nextText(), "goals" ) );
2724 }
2725 else
2726 {
2727 checkUnknownElement( parser, strict );
2728 }
2729 }
2730 pluginExecution.goals( goals );
2731 break;
2732 }
2733 case "inherited":
2734 {
2735 pluginExecution.inherited( interpolatedTrimmed( parser.nextText(), "inherited" ) );
2736 break;
2737 }
2738 case "configuration":
2739 {
2740 pluginExecution.configuration( XmlNodeBuilder.build( parser, true ) );
2741 break;
2742 }
2743 default:
2744 {
2745 checkUnknownElement( parser, strict );
2746 break;
2747 }
2748 }
2749 }
2750 return pluginExecution.build();
2751 }
2752
2753 private DependencyManagement parseDependencyManagement( XmlPullParser parser, boolean strict )
2754 throws IOException, XmlPullParserException
2755 {
2756 String tagName = parser.getName();
2757 DependencyManagement.Builder dependencyManagement = DependencyManagement.newBuilder( true );
2758 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2759 {
2760 String name = parser.getAttributeName( i );
2761 String value = parser.getAttributeValue( i );
2762 if ( name.indexOf( ':' ) >= 0 )
2763 {
2764
2765 }
2766 else
2767 {
2768 checkUnknownAttribute( parser, name, tagName, strict );
2769 }
2770 }
2771 Set<String> parsed = new HashSet<>();
2772 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2773 {
2774 String childName = unalias( parser.getName() );
2775 if ( !parsed.add( childName ) )
2776 {
2777 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2778 }
2779 switch ( childName )
2780 {
2781 case "dependencies":
2782 {
2783 List<Dependency> dependencies = new ArrayList<>();
2784 while ( parser.nextTag() == XmlPullParser.START_TAG )
2785 {
2786 if ( "dependency".equals( parser.getName() ) )
2787 {
2788 dependencies.add( parseDependency( parser, strict ) );
2789 }
2790 else
2791 {
2792 checkUnknownElement( parser, strict );
2793 }
2794 }
2795 dependencyManagement.dependencies( dependencies );
2796 break;
2797 }
2798 default:
2799 {
2800 checkUnknownElement( parser, strict );
2801 break;
2802 }
2803 }
2804 }
2805 return dependencyManagement.build();
2806 }
2807
2808 private PluginManagement parsePluginManagement( XmlPullParser parser, boolean strict )
2809 throws IOException, XmlPullParserException
2810 {
2811 String tagName = parser.getName();
2812 PluginManagement.Builder pluginManagement = PluginManagement.newBuilder( true );
2813 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2814 {
2815 String name = parser.getAttributeName( i );
2816 String value = parser.getAttributeValue( i );
2817 if ( name.indexOf( ':' ) >= 0 )
2818 {
2819
2820 }
2821 else
2822 {
2823 checkUnknownAttribute( parser, name, tagName, strict );
2824 }
2825 }
2826 Set<String> parsed = new HashSet<>();
2827 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2828 {
2829 String childName = unalias( parser.getName() );
2830 if ( !parsed.add( childName ) )
2831 {
2832 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2833 }
2834 switch ( childName )
2835 {
2836 case "plugins":
2837 {
2838 List<Plugin> plugins = new ArrayList<>();
2839 while ( parser.nextTag() == XmlPullParser.START_TAG )
2840 {
2841 if ( "plugin".equals( parser.getName() ) )
2842 {
2843 plugins.add( parsePlugin( parser, strict ) );
2844 }
2845 else
2846 {
2847 checkUnknownElement( parser, strict );
2848 }
2849 }
2850 pluginManagement.plugins( plugins );
2851 break;
2852 }
2853 default:
2854 {
2855 checkUnknownElement( parser, strict );
2856 break;
2857 }
2858 }
2859 }
2860 return pluginManagement.build();
2861 }
2862
2863 private Reporting parseReporting( XmlPullParser parser, boolean strict )
2864 throws IOException, XmlPullParserException
2865 {
2866 String tagName = parser.getName();
2867 Reporting.Builder reporting = Reporting.newBuilder( true );
2868 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2869 {
2870 String name = parser.getAttributeName( i );
2871 String value = parser.getAttributeValue( i );
2872 if ( name.indexOf( ':' ) >= 0 )
2873 {
2874
2875 }
2876 else
2877 {
2878 checkUnknownAttribute( parser, name, tagName, strict );
2879 }
2880 }
2881 Set<String> parsed = new HashSet<>();
2882 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2883 {
2884 String childName = unalias( parser.getName() );
2885 if ( !parsed.add( childName ) )
2886 {
2887 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2888 }
2889 switch ( childName )
2890 {
2891 case "excludeDefaults":
2892 {
2893 reporting.excludeDefaults( interpolatedTrimmed( parser.nextText(), "excludeDefaults" ) );
2894 break;
2895 }
2896 case "outputDirectory":
2897 {
2898 reporting.outputDirectory( interpolatedTrimmed( parser.nextText(), "outputDirectory" ) );
2899 break;
2900 }
2901 case "plugins":
2902 {
2903 List<ReportPlugin> plugins = new ArrayList<>();
2904 while ( parser.nextTag() == XmlPullParser.START_TAG )
2905 {
2906 if ( "plugin".equals( parser.getName() ) )
2907 {
2908 plugins.add( parseReportPlugin( parser, strict ) );
2909 }
2910 else
2911 {
2912 checkUnknownElement( parser, strict );
2913 }
2914 }
2915 reporting.plugins( plugins );
2916 break;
2917 }
2918 default:
2919 {
2920 checkUnknownElement( parser, strict );
2921 break;
2922 }
2923 }
2924 }
2925 return reporting.build();
2926 }
2927
2928 private Profile parseProfile( XmlPullParser parser, boolean strict )
2929 throws IOException, XmlPullParserException
2930 {
2931 String tagName = parser.getName();
2932 Profile.Builder profile = Profile.newBuilder( true );
2933 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
2934 {
2935 String name = parser.getAttributeName( i );
2936 String value = parser.getAttributeValue( i );
2937 if ( name.indexOf( ':' ) >= 0 )
2938 {
2939
2940 }
2941 else
2942 {
2943 checkUnknownAttribute( parser, name, tagName, strict );
2944 }
2945 }
2946 Set<String> parsed = new HashSet<>();
2947 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
2948 {
2949 String childName = unalias( parser.getName() );
2950 if ( !parsed.add( childName ) )
2951 {
2952 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
2953 }
2954 switch ( childName )
2955 {
2956 case "id":
2957 {
2958 profile.id( interpolatedTrimmed( parser.nextText(), "id" ) );
2959 break;
2960 }
2961 case "activation":
2962 {
2963 profile.activation( parseActivation( parser, strict ) );
2964 break;
2965 }
2966 case "build":
2967 {
2968 profile.build( parseBuildBase( parser, strict ) );
2969 break;
2970 }
2971 case "modules":
2972 {
2973 List<String> modules = new ArrayList<>();
2974 while ( parser.nextTag() == XmlPullParser.START_TAG )
2975 {
2976 if ( "module".equals( parser.getName() ) )
2977 {
2978 modules.add( interpolatedTrimmed( parser.nextText(), "modules" ) );
2979 }
2980 else
2981 {
2982 checkUnknownElement( parser, strict );
2983 }
2984 }
2985 profile.modules( modules );
2986 break;
2987 }
2988 case "distributionManagement":
2989 {
2990 profile.distributionManagement( parseDistributionManagement( parser, strict ) );
2991 break;
2992 }
2993 case "properties":
2994 {
2995 Map<String, String> properties = new LinkedHashMap<>();
2996 while ( parser.nextTag() == XmlPullParser.START_TAG )
2997 {
2998 String key = parser.getName();
2999 String value = parser.nextText().trim();
3000 properties.put( key, value );
3001 }
3002 profile.properties( properties );
3003 break;
3004 }
3005 case "dependencyManagement":
3006 {
3007 profile.dependencyManagement( parseDependencyManagement( parser, strict ) );
3008 break;
3009 }
3010 case "dependencies":
3011 {
3012 List<Dependency> dependencies = new ArrayList<>();
3013 while ( parser.nextTag() == XmlPullParser.START_TAG )
3014 {
3015 if ( "dependency".equals( parser.getName() ) )
3016 {
3017 dependencies.add( parseDependency( parser, strict ) );
3018 }
3019 else
3020 {
3021 checkUnknownElement( parser, strict );
3022 }
3023 }
3024 profile.dependencies( dependencies );
3025 break;
3026 }
3027 case "repositories":
3028 {
3029 List<Repository> repositories = new ArrayList<>();
3030 while ( parser.nextTag() == XmlPullParser.START_TAG )
3031 {
3032 if ( "repository".equals( parser.getName() ) )
3033 {
3034 repositories.add( parseRepository( parser, strict ) );
3035 }
3036 else
3037 {
3038 checkUnknownElement( parser, strict );
3039 }
3040 }
3041 profile.repositories( repositories );
3042 break;
3043 }
3044 case "pluginRepositories":
3045 {
3046 List<Repository> pluginRepositories = new ArrayList<>();
3047 while ( parser.nextTag() == XmlPullParser.START_TAG )
3048 {
3049 if ( "pluginRepository".equals( parser.getName() ) )
3050 {
3051 pluginRepositories.add( parseRepository( parser, strict ) );
3052 }
3053 else
3054 {
3055 checkUnknownElement( parser, strict );
3056 }
3057 }
3058 profile.pluginRepositories( pluginRepositories );
3059 break;
3060 }
3061 case "reporting":
3062 {
3063 profile.reporting( parseReporting( parser, strict ) );
3064 break;
3065 }
3066 default:
3067 {
3068 checkUnknownElement( parser, strict );
3069 break;
3070 }
3071 }
3072 }
3073 return profile.build();
3074 }
3075
3076 private Activation parseActivation( XmlPullParser parser, boolean strict )
3077 throws IOException, XmlPullParserException
3078 {
3079 String tagName = parser.getName();
3080 Activation.Builder activation = Activation.newBuilder( true );
3081 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3082 {
3083 String name = parser.getAttributeName( i );
3084 String value = parser.getAttributeValue( i );
3085 if ( name.indexOf( ':' ) >= 0 )
3086 {
3087
3088 }
3089 else
3090 {
3091 checkUnknownAttribute( parser, name, tagName, strict );
3092 }
3093 }
3094 Set<String> parsed = new HashSet<>();
3095 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3096 {
3097 String childName = unalias( parser.getName() );
3098 if ( !parsed.add( childName ) )
3099 {
3100 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3101 }
3102 switch ( childName )
3103 {
3104 case "activeByDefault":
3105 {
3106 activation.activeByDefault( getBooleanValue( interpolatedTrimmed( parser.nextText(), "activeByDefault" ), "activeByDefault", parser, false ) );
3107 break;
3108 }
3109 case "jdk":
3110 {
3111 activation.jdk( interpolatedTrimmed( parser.nextText(), "jdk" ) );
3112 break;
3113 }
3114 case "os":
3115 {
3116 activation.os( parseActivationOS( parser, strict ) );
3117 break;
3118 }
3119 case "property":
3120 {
3121 activation.property( parseActivationProperty( parser, strict ) );
3122 break;
3123 }
3124 case "file":
3125 {
3126 activation.file( parseActivationFile( parser, strict ) );
3127 break;
3128 }
3129 default:
3130 {
3131 checkUnknownElement( parser, strict );
3132 break;
3133 }
3134 }
3135 }
3136 return activation.build();
3137 }
3138
3139 private ActivationProperty parseActivationProperty( XmlPullParser parser, boolean strict )
3140 throws IOException, XmlPullParserException
3141 {
3142 String tagName = parser.getName();
3143 ActivationProperty.Builder activationProperty = ActivationProperty.newBuilder( true );
3144 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3145 {
3146 String name = parser.getAttributeName( i );
3147 String value = parser.getAttributeValue( i );
3148 if ( name.indexOf( ':' ) >= 0 )
3149 {
3150
3151 }
3152 else
3153 {
3154 checkUnknownAttribute( parser, name, tagName, strict );
3155 }
3156 }
3157 Set<String> parsed = new HashSet<>();
3158 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3159 {
3160 String childName = unalias( parser.getName() );
3161 if ( !parsed.add( childName ) )
3162 {
3163 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3164 }
3165 switch ( childName )
3166 {
3167 case "name":
3168 {
3169 activationProperty.name( interpolatedTrimmed( parser.nextText(), "name" ) );
3170 break;
3171 }
3172 case "value":
3173 {
3174 activationProperty.value( interpolatedTrimmed( parser.nextText(), "value" ) );
3175 break;
3176 }
3177 default:
3178 {
3179 checkUnknownElement( parser, strict );
3180 break;
3181 }
3182 }
3183 }
3184 return activationProperty.build();
3185 }
3186
3187 private ActivationOS parseActivationOS( XmlPullParser parser, boolean strict )
3188 throws IOException, XmlPullParserException
3189 {
3190 String tagName = parser.getName();
3191 ActivationOS.Builder activationOS = ActivationOS.newBuilder( true );
3192 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3193 {
3194 String name = parser.getAttributeName( i );
3195 String value = parser.getAttributeValue( i );
3196 if ( name.indexOf( ':' ) >= 0 )
3197 {
3198
3199 }
3200 else
3201 {
3202 checkUnknownAttribute( parser, name, tagName, strict );
3203 }
3204 }
3205 Set<String> parsed = new HashSet<>();
3206 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3207 {
3208 String childName = unalias( parser.getName() );
3209 if ( !parsed.add( childName ) )
3210 {
3211 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3212 }
3213 switch ( childName )
3214 {
3215 case "name":
3216 {
3217 activationOS.name( interpolatedTrimmed( parser.nextText(), "name" ) );
3218 break;
3219 }
3220 case "family":
3221 {
3222 activationOS.family( interpolatedTrimmed( parser.nextText(), "family" ) );
3223 break;
3224 }
3225 case "arch":
3226 {
3227 activationOS.arch( interpolatedTrimmed( parser.nextText(), "arch" ) );
3228 break;
3229 }
3230 case "version":
3231 {
3232 activationOS.version( interpolatedTrimmed( parser.nextText(), "version" ) );
3233 break;
3234 }
3235 default:
3236 {
3237 checkUnknownElement( parser, strict );
3238 break;
3239 }
3240 }
3241 }
3242 return activationOS.build();
3243 }
3244
3245 private ActivationFile parseActivationFile( XmlPullParser parser, boolean strict )
3246 throws IOException, XmlPullParserException
3247 {
3248 String tagName = parser.getName();
3249 ActivationFile.Builder activationFile = ActivationFile.newBuilder( true );
3250 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3251 {
3252 String name = parser.getAttributeName( i );
3253 String value = parser.getAttributeValue( i );
3254 if ( name.indexOf( ':' ) >= 0 )
3255 {
3256
3257 }
3258 else
3259 {
3260 checkUnknownAttribute( parser, name, tagName, strict );
3261 }
3262 }
3263 Set<String> parsed = new HashSet<>();
3264 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3265 {
3266 String childName = unalias( parser.getName() );
3267 if ( !parsed.add( childName ) )
3268 {
3269 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3270 }
3271 switch ( childName )
3272 {
3273 case "missing":
3274 {
3275 activationFile.missing( interpolatedTrimmed( parser.nextText(), "missing" ) );
3276 break;
3277 }
3278 case "exists":
3279 {
3280 activationFile.exists( interpolatedTrimmed( parser.nextText(), "exists" ) );
3281 break;
3282 }
3283 default:
3284 {
3285 checkUnknownElement( parser, strict );
3286 break;
3287 }
3288 }
3289 }
3290 return activationFile.build();
3291 }
3292
3293 private ReportPlugin parseReportPlugin( XmlPullParser parser, boolean strict )
3294 throws IOException, XmlPullParserException
3295 {
3296 String tagName = parser.getName();
3297 ReportPlugin.Builder reportPlugin = ReportPlugin.newBuilder( true );
3298 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3299 {
3300 String name = parser.getAttributeName( i );
3301 String value = parser.getAttributeValue( i );
3302 if ( name.indexOf( ':' ) >= 0 )
3303 {
3304
3305 }
3306 else
3307 {
3308 checkUnknownAttribute( parser, name, tagName, strict );
3309 }
3310 }
3311 Set<String> parsed = new HashSet<>();
3312 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3313 {
3314 String childName = unalias( parser.getName() );
3315 if ( !parsed.add( childName ) )
3316 {
3317 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3318 }
3319 switch ( childName )
3320 {
3321 case "groupId":
3322 {
3323 reportPlugin.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
3324 break;
3325 }
3326 case "artifactId":
3327 {
3328 reportPlugin.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
3329 break;
3330 }
3331 case "version":
3332 {
3333 reportPlugin.version( interpolatedTrimmed( parser.nextText(), "version" ) );
3334 break;
3335 }
3336 case "reportSets":
3337 {
3338 List<ReportSet> reportSets = new ArrayList<>();
3339 while ( parser.nextTag() == XmlPullParser.START_TAG )
3340 {
3341 if ( "reportSet".equals( parser.getName() ) )
3342 {
3343 reportSets.add( parseReportSet( parser, strict ) );
3344 }
3345 else
3346 {
3347 checkUnknownElement( parser, strict );
3348 }
3349 }
3350 reportPlugin.reportSets( reportSets );
3351 break;
3352 }
3353 case "inherited":
3354 {
3355 reportPlugin.inherited( interpolatedTrimmed( parser.nextText(), "inherited" ) );
3356 break;
3357 }
3358 case "configuration":
3359 {
3360 reportPlugin.configuration( XmlNodeBuilder.build( parser, true ) );
3361 break;
3362 }
3363 default:
3364 {
3365 checkUnknownElement( parser, strict );
3366 break;
3367 }
3368 }
3369 }
3370 return reportPlugin.build();
3371 }
3372
3373 private ReportSet parseReportSet( XmlPullParser parser, boolean strict )
3374 throws IOException, XmlPullParserException
3375 {
3376 String tagName = parser.getName();
3377 ReportSet.Builder reportSet = ReportSet.newBuilder( true );
3378 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3379 {
3380 String name = parser.getAttributeName( i );
3381 String value = parser.getAttributeValue( i );
3382 if ( name.indexOf( ':' ) >= 0 )
3383 {
3384
3385 }
3386 else
3387 {
3388 checkUnknownAttribute( parser, name, tagName, strict );
3389 }
3390 }
3391 Set<String> parsed = new HashSet<>();
3392 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3393 {
3394 String childName = unalias( parser.getName() );
3395 if ( !parsed.add( childName ) )
3396 {
3397 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3398 }
3399 switch ( childName )
3400 {
3401 case "id":
3402 {
3403 reportSet.id( interpolatedTrimmed( parser.nextText(), "id" ) );
3404 break;
3405 }
3406 case "reports":
3407 {
3408 List<String> reports = new ArrayList<>();
3409 while ( parser.nextTag() == XmlPullParser.START_TAG )
3410 {
3411 if ( "report".equals( parser.getName() ) )
3412 {
3413 reports.add( interpolatedTrimmed( parser.nextText(), "reports" ) );
3414 }
3415 else
3416 {
3417 checkUnknownElement( parser, strict );
3418 }
3419 }
3420 reportSet.reports( reports );
3421 break;
3422 }
3423 case "inherited":
3424 {
3425 reportSet.inherited( interpolatedTrimmed( parser.nextText(), "inherited" ) );
3426 break;
3427 }
3428 case "configuration":
3429 {
3430 reportSet.configuration( XmlNodeBuilder.build( parser, true ) );
3431 break;
3432 }
3433 default:
3434 {
3435 checkUnknownElement( parser, strict );
3436 break;
3437 }
3438 }
3439 }
3440 return reportSet.build();
3441 }
3442
3443 private Prerequisites parsePrerequisites( XmlPullParser parser, boolean strict )
3444 throws IOException, XmlPullParserException
3445 {
3446 String tagName = parser.getName();
3447 Prerequisites.Builder prerequisites = Prerequisites.newBuilder( true );
3448 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3449 {
3450 String name = parser.getAttributeName( i );
3451 String value = parser.getAttributeValue( i );
3452 if ( name.indexOf( ':' ) >= 0 )
3453 {
3454
3455 }
3456 else
3457 {
3458 checkUnknownAttribute( parser, name, tagName, strict );
3459 }
3460 }
3461 Set<String> parsed = new HashSet<>();
3462 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3463 {
3464 String childName = unalias( parser.getName() );
3465 if ( !parsed.add( childName ) )
3466 {
3467 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3468 }
3469 switch ( childName )
3470 {
3471 case "maven":
3472 {
3473 prerequisites.maven( interpolatedTrimmed( parser.nextText(), "maven" ) );
3474 break;
3475 }
3476 default:
3477 {
3478 checkUnknownElement( parser, strict );
3479 break;
3480 }
3481 }
3482 }
3483 return prerequisites.build();
3484 }
3485
3486 private Relocation parseRelocation( XmlPullParser parser, boolean strict )
3487 throws IOException, XmlPullParserException
3488 {
3489 String tagName = parser.getName();
3490 Relocation.Builder relocation = Relocation.newBuilder( true );
3491 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3492 {
3493 String name = parser.getAttributeName( i );
3494 String value = parser.getAttributeValue( i );
3495 if ( name.indexOf( ':' ) >= 0 )
3496 {
3497
3498 }
3499 else
3500 {
3501 checkUnknownAttribute( parser, name, tagName, strict );
3502 }
3503 }
3504 Set<String> parsed = new HashSet<>();
3505 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3506 {
3507 String childName = unalias( parser.getName() );
3508 if ( !parsed.add( childName ) )
3509 {
3510 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3511 }
3512 switch ( childName )
3513 {
3514 case "groupId":
3515 {
3516 relocation.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
3517 break;
3518 }
3519 case "artifactId":
3520 {
3521 relocation.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
3522 break;
3523 }
3524 case "version":
3525 {
3526 relocation.version( interpolatedTrimmed( parser.nextText(), "version" ) );
3527 break;
3528 }
3529 case "message":
3530 {
3531 relocation.message( interpolatedTrimmed( parser.nextText(), "message" ) );
3532 break;
3533 }
3534 default:
3535 {
3536 checkUnknownElement( parser, strict );
3537 break;
3538 }
3539 }
3540 }
3541 return relocation.build();
3542 }
3543
3544 private Extension parseExtension( XmlPullParser parser, boolean strict )
3545 throws IOException, XmlPullParserException
3546 {
3547 String tagName = parser.getName();
3548 Extension.Builder extension = Extension.newBuilder( true );
3549 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
3550 {
3551 String name = parser.getAttributeName( i );
3552 String value = parser.getAttributeValue( i );
3553 if ( name.indexOf( ':' ) >= 0 )
3554 {
3555
3556 }
3557 else
3558 {
3559 checkUnknownAttribute( parser, name, tagName, strict );
3560 }
3561 }
3562 Set<String> parsed = new HashSet<>();
3563 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
3564 {
3565 String childName = unalias( parser.getName() );
3566 if ( !parsed.add( childName ) )
3567 {
3568 throw new XmlPullParserException( "Duplicated tag: '" + childName + "'", parser, null );
3569 }
3570 switch ( childName )
3571 {
3572 case "groupId":
3573 {
3574 extension.groupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
3575 break;
3576 }
3577 case "artifactId":
3578 {
3579 extension.artifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
3580 break;
3581 }
3582 case "version":
3583 {
3584 extension.version( interpolatedTrimmed( parser.nextText(), "version" ) );
3585 break;
3586 }
3587 default:
3588 {
3589 checkUnknownElement( parser, strict );
3590 break;
3591 }
3592 }
3593 }
3594 return extension.build();
3595 }
3596
3597
3598 private String unalias( String tagName )
3599 {
3600 switch ( tagName )
3601 {
3602 case "organisation":
3603 return "organization";
3604 case "organisationUrl":
3605 return "organizationUrl";
3606 default:
3607 return tagName;
3608 }
3609 }
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622 private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
3623 throws XmlPullParserException, IOException
3624 {
3625
3626 if ( strict )
3627 {
3628 throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
3629 }
3630 }
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641 private void checkUnknownElement( XmlPullParser parser, boolean strict )
3642 throws XmlPullParserException, IOException
3643 {
3644 if ( strict )
3645 {
3646 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3647 }
3648
3649 for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
3650 {
3651 int eventType = parser.next();
3652 if ( eventType == XmlPullParser.START_TAG )
3653 {
3654 unrecognizedTagCount++;
3655 }
3656 else if ( eventType == XmlPullParser.END_TAG )
3657 {
3658 unrecognizedTagCount--;
3659 }
3660 }
3661 }
3662
3663
3664
3665
3666
3667
3668
3669 private String getTrimmedValue( String s )
3670 {
3671 if ( s != null )
3672 {
3673 s = s.trim();
3674 }
3675 return s;
3676 }
3677
3678
3679
3680
3681
3682
3683
3684
3685 private String interpolatedTrimmed( String value, String context )
3686 {
3687 return getTrimmedValue( contentTransformer.transform( value, context ) );
3688 }
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699 private int nextTag( XmlPullParser parser )
3700 throws IOException, XmlPullParserException
3701 {
3702 int eventType = parser.next();
3703 if ( eventType == XmlPullParser.TEXT )
3704 {
3705 eventType = parser.next();
3706 }
3707 if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
3708 {
3709 throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
3710 }
3711 return eventType;
3712 }
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, boolean defaultValue )
3726 throws XmlPullParserException
3727 {
3728 if ( s != null && s.length() != 0 )
3729 {
3730 return Boolean.valueOf( s ).booleanValue();
3731 }
3732 return defaultValue;
3733 }
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict, int defaultValue )
3747 throws XmlPullParserException
3748 {
3749 if ( s != null )
3750 {
3751 try
3752 {
3753 return Integer.valueOf( s ).intValue();
3754 }
3755 catch ( NumberFormatException nfe )
3756 {
3757 if ( strict )
3758 {
3759 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
3760 }
3761 }
3762 }
3763 return defaultValue;
3764 }
3765
3766 public static interface ContentTransformer
3767 {
3768
3769
3770
3771
3772
3773
3774
3775 String transform( String source, String fieldName );
3776 }
3777
3778 }