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