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