1
2
3
4 package org.apache.maven.settings.v4;
5
6 import java.io.IOException;
7 import java.io.InputStream;
8 import java.io.Reader;
9 import java.text.DateFormat;
10 import java.util.ArrayList;
11 import java.util.Date;
12 import java.util.HashMap;
13 import java.util.HashSet;
14 import java.util.LinkedHashMap;
15 import java.util.List;
16 import java.util.Map;
17 import java.util.Properties;
18 import java.util.Set;
19 import org.apache.maven.api.annotations.Generated;
20 import org.apache.maven.internal.xml.DomBuilder;
21 import org.apache.maven.api.settings.TrackableBase;
22 import org.apache.maven.api.settings.IdentifiableBase;
23 import org.apache.maven.api.settings.Settings;
24 import org.apache.maven.api.settings.Proxy;
25 import org.apache.maven.api.settings.Server;
26 import org.apache.maven.api.settings.Mirror;
27 import org.apache.maven.api.settings.Profile;
28 import org.apache.maven.api.settings.Activation;
29 import org.apache.maven.api.settings.RepositoryBase;
30 import org.apache.maven.api.settings.Repository;
31 import org.apache.maven.api.settings.RepositoryPolicy;
32 import org.apache.maven.api.settings.ActivationProperty;
33 import org.apache.maven.api.settings.ActivationOS;
34 import org.apache.maven.api.settings.ActivationFile;
35 import org.codehaus.plexus.util.ReaderFactory;
36 import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
37 import org.codehaus.plexus.util.xml.pull.MXParser;
38 import org.codehaus.plexus.util.xml.pull.XmlPullParser;
39 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
40
41 @Generated
42 public class SettingsXpp3Reader
43 {
44 private boolean addDefaultEntities = true;
45
46 private final ContentTransformer contentTransformer;
47
48 public SettingsXpp3Reader()
49 {
50 this( ( s, f ) -> s );
51 }
52
53 public SettingsXpp3Reader( ContentTransformer contentTransformer )
54 {
55 this.contentTransformer = contentTransformer;
56 }
57
58
59
60
61
62
63
64
65
66
67
68
69 private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, Set<String> parsed )
70 throws XmlPullParserException
71 {
72 if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
73 {
74 return false;
75 }
76 if ( !parsed.add( tagName ) )
77 {
78 throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
79 }
80 return true;
81 }
82
83
84
85
86
87
88
89
90
91
92
93
94 private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
95 throws XmlPullParserException, IOException
96 {
97
98 if ( strict )
99 {
100 throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
101 }
102 }
103
104
105
106
107
108
109
110
111
112
113 private void checkUnknownElement( XmlPullParser parser, boolean strict )
114 throws XmlPullParserException, IOException
115 {
116 if ( strict )
117 {
118 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
119 }
120
121 for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
122 {
123 int eventType = parser.next();
124 if ( eventType == XmlPullParser.START_TAG )
125 {
126 unrecognizedTagCount++;
127 }
128 else if ( eventType == XmlPullParser.END_TAG )
129 {
130 unrecognizedTagCount--;
131 }
132 }
133 }
134
135
136
137
138
139
140 public boolean getAddDefaultEntities()
141 {
142 return addDefaultEntities;
143 }
144
145
146
147
148
149
150
151
152
153
154
155 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
156 throws XmlPullParserException
157 {
158 return getBooleanValue( s, attribute, parser, null );
159 }
160
161
162
163
164
165
166
167
168
169
170
171
172 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
173 throws XmlPullParserException
174 {
175 if ( s != null && s.length() != 0 )
176 {
177 return Boolean.valueOf( s ).booleanValue();
178 }
179 if ( defaultValue != null )
180 {
181 return Boolean.valueOf( defaultValue ).booleanValue();
182 }
183 return false;
184 }
185
186
187
188
189
190
191
192
193
194
195
196
197 private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
198 throws XmlPullParserException
199 {
200 if ( s != null )
201 {
202 try
203 {
204 return Byte.valueOf( s ).byteValue();
205 }
206 catch ( NumberFormatException nfe )
207 {
208 if ( strict )
209 {
210 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
211 }
212 }
213 }
214 return 0;
215 }
216
217
218
219
220
221
222
223
224
225
226
227 private char getCharacterValue( String s, String attribute, XmlPullParser parser )
228 throws XmlPullParserException
229 {
230 if ( s != null )
231 {
232 return s.charAt( 0 );
233 }
234 return 0;
235 }
236
237
238
239
240
241
242
243
244
245
246
247 private Date getDateValue( String s, String attribute, XmlPullParser parser )
248 throws XmlPullParserException
249 {
250 return getDateValue( s, attribute, null, parser );
251 }
252
253
254
255
256
257
258
259
260
261
262
263
264 private Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
265 throws XmlPullParserException
266 {
267 if ( s != null )
268 {
269 String effectiveDateFormat = dateFormat;
270 if ( dateFormat == null )
271 {
272 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
273 }
274 if ( "long".equals( effectiveDateFormat ) )
275 {
276 try
277 {
278 return new java.util.Date( Long.parseLong( s ) );
279 }
280 catch ( NumberFormatException e )
281 {
282 throw new XmlPullParserException( e.getMessage(), parser, e );
283 }
284 }
285 else
286 {
287 try
288 {
289 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
290 return dateParser.parse( s );
291 }
292 catch ( java.text.ParseException e )
293 {
294 throw new XmlPullParserException( e.getMessage(), parser, e );
295 }
296 }
297 }
298 return null;
299 }
300
301
302
303
304
305
306
307
308
309
310
311
312 private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
313 throws XmlPullParserException
314 {
315 if ( s != null )
316 {
317 try
318 {
319 return Double.valueOf( s ).doubleValue();
320 }
321 catch ( NumberFormatException nfe )
322 {
323 if ( strict )
324 {
325 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
326 }
327 }
328 }
329 return 0;
330 }
331
332
333
334
335
336
337
338
339
340
341
342
343 private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
344 throws XmlPullParserException
345 {
346 if ( s != null )
347 {
348 try
349 {
350 return Float.valueOf( s ).floatValue();
351 }
352 catch ( NumberFormatException nfe )
353 {
354 if ( strict )
355 {
356 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
357 }
358 }
359 }
360 return 0;
361 }
362
363
364
365
366
367
368
369
370
371
372
373 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
374 throws XmlPullParserException
375 {
376 return getIntegerValue( s, attribute, parser, strict, 0 );
377 }
378
379
380
381
382
383
384
385
386
387
388
389
390 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict, int defaultValue )
391 throws XmlPullParserException
392 {
393 if ( s != null )
394 {
395 try
396 {
397 return Integer.valueOf( s ).intValue();
398 }
399 catch ( NumberFormatException nfe )
400 {
401 if ( strict )
402 {
403 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
404 }
405 }
406 }
407 return defaultValue;
408 }
409
410
411
412
413
414
415
416
417
418
419
420
421 private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
422 throws XmlPullParserException
423 {
424 if ( s != null )
425 {
426 try
427 {
428 return Long.valueOf( s ).longValue();
429 }
430 catch ( NumberFormatException nfe )
431 {
432 if ( strict )
433 {
434 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
435 }
436 }
437 }
438 return 0;
439 }
440
441
442
443
444
445
446
447
448
449
450
451
452 private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
453 throws XmlPullParserException
454 {
455 if ( s == null )
456 {
457 if ( strict )
458 {
459 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
460 }
461 }
462 return s;
463 }
464
465
466
467
468
469
470
471
472
473
474
475
476 private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
477 throws XmlPullParserException
478 {
479 if ( s != null )
480 {
481 try
482 {
483 return Short.valueOf( s ).shortValue();
484 }
485 catch ( NumberFormatException nfe )
486 {
487 if ( strict )
488 {
489 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
490 }
491 }
492 }
493 return 0;
494 }
495
496
497
498
499
500
501
502 private String getTrimmedValue( String s )
503 {
504 if ( s != null )
505 {
506 s = s.trim();
507 }
508 return s;
509 }
510
511
512
513
514
515
516
517
518 private String interpolatedTrimmed( String value, String context )
519 {
520 return getTrimmedValue( contentTransformer.transform( value, context ) );
521 }
522
523
524
525
526
527
528
529
530
531
532 private int nextTag( XmlPullParser parser )
533 throws IOException, XmlPullParserException
534 {
535 int eventType = parser.next();
536 if ( eventType == XmlPullParser.TEXT )
537 {
538 eventType = parser.next();
539 }
540 if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
541 {
542 throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
543 }
544 return eventType;
545 }
546
547
548
549
550
551
552
553
554
555
556
557 public Settings read( Reader reader, boolean strict )
558 throws IOException, XmlPullParserException
559 {
560 XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
561
562 parser.setInput( reader );
563
564
565 return read( parser, strict );
566 }
567
568
569
570
571
572
573
574
575
576
577 public Settings read( Reader reader )
578 throws IOException, XmlPullParserException
579 {
580 return read( reader, true );
581 }
582
583
584
585
586
587
588
589
590
591
592
593 public Settings read( InputStream in, boolean strict )
594 throws IOException, XmlPullParserException
595 {
596 return read( ReaderFactory.newXmlReader( in ), strict );
597 }
598
599
600
601
602
603
604
605
606
607
608 public Settings read( InputStream in )
609 throws IOException, XmlPullParserException
610 {
611 return read( ReaderFactory.newXmlReader( in ) );
612 }
613
614
615
616
617
618
619
620
621
622
623
624 public Settings read( XmlPullParser parser, boolean strict )
625 throws IOException, XmlPullParserException
626 {
627 Settings settings = null;
628 int eventType = parser.getEventType();
629 boolean parsed = false;
630 while ( eventType != XmlPullParser.END_DOCUMENT )
631 {
632 if ( eventType == XmlPullParser.START_TAG )
633 {
634 if ( strict && ! "settings".equals( parser.getName() ) )
635 {
636 throw new XmlPullParserException( "Expected root element 'settings' but found '" + parser.getName() + "'", parser, null );
637 }
638 else if ( parsed )
639 {
640
641 throw new XmlPullParserException( "Duplicated tag: 'settings'", parser, null );
642 }
643 settings = parseSettings( parser, strict );
644 parsed = true;
645 }
646 eventType = parser.next();
647 }
648 if ( parsed )
649 {
650 return settings;
651 }
652 throw new XmlPullParserException( "Expected root element 'settings' but found no element at all: invalid XML document", parser, null );
653 }
654
655 private TrackableBase parseTrackableBase( XmlPullParser parser, boolean strict )
656 throws IOException, XmlPullParserException
657 {
658 String tagName = parser.getName();
659 TrackableBase.Builder trackableBase = TrackableBase.newBuilder( true );
660 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
661 {
662 String name = parser.getAttributeName( i );
663 String value = parser.getAttributeValue( i );
664 if ( name.indexOf( ':' ) >= 0 )
665 {
666
667 }
668 else
669 {
670 checkUnknownAttribute( parser, name, tagName, strict );
671 }
672 }
673 Set<String> parsed = new HashSet<>();
674 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
675 {
676 String childName = checkDuplicate( parser.getName(), parser, parsed );
677 switch ( childName )
678 {
679 default:
680 {
681 checkUnknownElement( parser, strict );
682 break;
683 }
684 }
685 }
686 return trackableBase.build();
687 }
688
689 private IdentifiableBase parseIdentifiableBase( XmlPullParser parser, boolean strict )
690 throws IOException, XmlPullParserException
691 {
692 String tagName = parser.getName();
693 IdentifiableBase.Builder identifiableBase = IdentifiableBase.newBuilder( true );
694 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
695 {
696 String name = parser.getAttributeName( i );
697 String value = parser.getAttributeValue( i );
698 if ( name.indexOf( ':' ) >= 0 )
699 {
700
701 }
702 else
703 {
704 checkUnknownAttribute( parser, name, tagName, strict );
705 }
706 }
707 Set<String> parsed = new HashSet<>();
708 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
709 {
710 String childName = checkDuplicate( parser.getName(), parser, parsed );
711 switch ( childName )
712 {
713 case "id":
714 {
715 identifiableBase.id( interpolatedTrimmed( parser.nextText(), "id" ) );
716 break;
717 }
718 default:
719 {
720 checkUnknownElement( parser, strict );
721 break;
722 }
723 }
724 }
725 return identifiableBase.build();
726 }
727
728 private Settings parseSettings( XmlPullParser parser, boolean strict )
729 throws IOException, XmlPullParserException
730 {
731 String tagName = parser.getName();
732 Settings.Builder settings = Settings.newBuilder( true );
733 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
734 {
735 String name = parser.getAttributeName( i );
736 String value = parser.getAttributeValue( i );
737 if ( name.indexOf( ':' ) >= 0 )
738 {
739
740 }
741 else if ( "xmlns".equals( name ) )
742 {
743
744 }
745 else
746 {
747 checkUnknownAttribute( parser, name, tagName, strict );
748 }
749 }
750 Set<String> parsed = new HashSet<>();
751 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
752 {
753 String childName = checkDuplicate( parser.getName(), parser, parsed );
754 switch ( childName )
755 {
756 case "localRepository":
757 {
758 settings.localRepository( interpolatedTrimmed( parser.nextText(), "localRepository" ) );
759 break;
760 }
761 case "interactiveMode":
762 {
763 settings.interactiveMode( getBooleanValue( interpolatedTrimmed( parser.nextText(), "interactiveMode" ), "interactiveMode", parser, "true" ) );
764 break;
765 }
766 case "usePluginRegistry":
767 {
768 settings.usePluginRegistry( getBooleanValue( interpolatedTrimmed( parser.nextText(), "usePluginRegistry" ), "usePluginRegistry", parser, "false" ) );
769 break;
770 }
771 case "offline":
772 {
773 settings.offline( getBooleanValue( interpolatedTrimmed( parser.nextText(), "offline" ), "offline", parser, "false" ) );
774 break;
775 }
776 case "proxies":
777 {
778 List<Proxy> proxies = new ArrayList<>();
779 while ( parser.nextTag() == XmlPullParser.START_TAG )
780 {
781 if ( "proxy".equals( parser.getName() ) )
782 {
783 proxies.add( parseProxy( parser, strict ) );
784 }
785 else
786 {
787 checkUnknownElement( parser, strict );
788 }
789 }
790 settings.proxies( proxies );
791 break;
792 }
793 case "servers":
794 {
795 List<Server> servers = new ArrayList<>();
796 while ( parser.nextTag() == XmlPullParser.START_TAG )
797 {
798 if ( "server".equals( parser.getName() ) )
799 {
800 servers.add( parseServer( parser, strict ) );
801 }
802 else
803 {
804 checkUnknownElement( parser, strict );
805 }
806 }
807 settings.servers( servers );
808 break;
809 }
810 case "mirrors":
811 {
812 List<Mirror> mirrors = new ArrayList<>();
813 while ( parser.nextTag() == XmlPullParser.START_TAG )
814 {
815 if ( "mirror".equals( parser.getName() ) )
816 {
817 mirrors.add( parseMirror( parser, strict ) );
818 }
819 else
820 {
821 checkUnknownElement( parser, strict );
822 }
823 }
824 settings.mirrors( mirrors );
825 break;
826 }
827 case "profiles":
828 {
829 List<Profile> profiles = new ArrayList<>();
830 while ( parser.nextTag() == XmlPullParser.START_TAG )
831 {
832 if ( "profile".equals( parser.getName() ) )
833 {
834 profiles.add( parseProfile( parser, strict ) );
835 }
836 else
837 {
838 checkUnknownElement( parser, strict );
839 }
840 }
841 settings.profiles( profiles );
842 break;
843 }
844 case "activeProfiles":
845 {
846 List<String> activeProfiles = new ArrayList<>();
847 while ( parser.nextTag() == XmlPullParser.START_TAG )
848 {
849 if ( "activeProfile".equals( parser.getName() ) )
850 {
851 activeProfiles.add( interpolatedTrimmed( parser.nextText(), "activeProfiles" ) );
852 }
853 else
854 {
855 checkUnknownElement( parser, strict );
856 }
857 }
858 settings.activeProfiles( activeProfiles );
859 break;
860 }
861 case "pluginGroups":
862 {
863 List<String> pluginGroups = new ArrayList<>();
864 while ( parser.nextTag() == XmlPullParser.START_TAG )
865 {
866 if ( "pluginGroup".equals( parser.getName() ) )
867 {
868 pluginGroups.add( interpolatedTrimmed( parser.nextText(), "pluginGroups" ) );
869 }
870 else
871 {
872 checkUnknownElement( parser, strict );
873 }
874 }
875 settings.pluginGroups( pluginGroups );
876 break;
877 }
878 default:
879 {
880 checkUnknownElement( parser, strict );
881 break;
882 }
883 }
884 }
885 settings.modelEncoding( parser.getInputEncoding() );
886 return settings.build();
887 }
888
889 private Proxy parseProxy( XmlPullParser parser, boolean strict )
890 throws IOException, XmlPullParserException
891 {
892 String tagName = parser.getName();
893 Proxy.Builder proxy = Proxy.newBuilder( true );
894 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
895 {
896 String name = parser.getAttributeName( i );
897 String value = parser.getAttributeValue( i );
898 if ( name.indexOf( ':' ) >= 0 )
899 {
900
901 }
902 else
903 {
904 checkUnknownAttribute( parser, name, tagName, strict );
905 }
906 }
907 Set<String> parsed = new HashSet<>();
908 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
909 {
910 String childName = checkDuplicate( parser.getName(), parser, parsed );
911 switch ( childName )
912 {
913 case "id":
914 {
915 proxy.id( interpolatedTrimmed( parser.nextText(), "id" ) );
916 break;
917 }
918 case "active":
919 {
920 proxy.active( getBooleanValue( interpolatedTrimmed( parser.nextText(), "active" ), "active", parser, "true" ) );
921 break;
922 }
923 case "protocol":
924 {
925 proxy.protocol( interpolatedTrimmed( parser.nextText(), "protocol" ) );
926 break;
927 }
928 case "username":
929 {
930 proxy.username( interpolatedTrimmed( parser.nextText(), "username" ) );
931 break;
932 }
933 case "password":
934 {
935 proxy.password( interpolatedTrimmed( parser.nextText(), "password" ) );
936 break;
937 }
938 case "port":
939 {
940 proxy.port( getIntegerValue( interpolatedTrimmed( parser.nextText(), "port" ), "port", parser, strict, 8080 ) );
941 break;
942 }
943 case "host":
944 {
945 proxy.host( interpolatedTrimmed( parser.nextText(), "host" ) );
946 break;
947 }
948 case "nonProxyHosts":
949 {
950 proxy.nonProxyHosts( interpolatedTrimmed( parser.nextText(), "nonProxyHosts" ) );
951 break;
952 }
953 default:
954 {
955 checkUnknownElement( parser, strict );
956 break;
957 }
958 }
959 }
960 return proxy.build();
961 }
962
963 private Server parseServer( XmlPullParser parser, boolean strict )
964 throws IOException, XmlPullParserException
965 {
966 String tagName = parser.getName();
967 Server.Builder server = Server.newBuilder( true );
968 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
969 {
970 String name = parser.getAttributeName( i );
971 String value = parser.getAttributeValue( i );
972 if ( name.indexOf( ':' ) >= 0 )
973 {
974
975 }
976 else
977 {
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 {
984 String childName = checkDuplicate( parser.getName(), parser, parsed );
985 switch ( childName )
986 {
987 case "id":
988 {
989 server.id( interpolatedTrimmed( parser.nextText(), "id" ) );
990 break;
991 }
992 case "username":
993 {
994 server.username( interpolatedTrimmed( parser.nextText(), "username" ) );
995 break;
996 }
997 case "password":
998 {
999 server.password( interpolatedTrimmed( parser.nextText(), "password" ) );
1000 break;
1001 }
1002 case "privateKey":
1003 {
1004 server.privateKey( interpolatedTrimmed( parser.nextText(), "privateKey" ) );
1005 break;
1006 }
1007 case "passphrase":
1008 {
1009 server.passphrase( interpolatedTrimmed( parser.nextText(), "passphrase" ) );
1010 break;
1011 }
1012 case "filePermissions":
1013 {
1014 server.filePermissions( interpolatedTrimmed( parser.nextText(), "filePermissions" ) );
1015 break;
1016 }
1017 case "directoryPermissions":
1018 {
1019 server.directoryPermissions( interpolatedTrimmed( parser.nextText(), "directoryPermissions" ) );
1020 break;
1021 }
1022 case "configuration":
1023 {
1024 server.configuration( DomBuilder.build( parser, true ) );
1025 break;
1026 }
1027 default:
1028 {
1029 checkUnknownElement( parser, strict );
1030 break;
1031 }
1032 }
1033 }
1034 return server.build();
1035 }
1036
1037 private Mirror parseMirror( XmlPullParser parser, boolean strict )
1038 throws IOException, XmlPullParserException
1039 {
1040 String tagName = parser.getName();
1041 Mirror.Builder mirror = Mirror.newBuilder( true );
1042 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1043 {
1044 String name = parser.getAttributeName( i );
1045 String value = parser.getAttributeValue( i );
1046 if ( name.indexOf( ':' ) >= 0 )
1047 {
1048
1049 }
1050 else
1051 {
1052 checkUnknownAttribute( parser, name, tagName, strict );
1053 }
1054 }
1055 Set<String> parsed = new HashSet<>();
1056 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1057 {
1058 String childName = checkDuplicate( parser.getName(), parser, parsed );
1059 switch ( childName )
1060 {
1061 case "id":
1062 {
1063 mirror.id( interpolatedTrimmed( parser.nextText(), "id" ) );
1064 break;
1065 }
1066 case "mirrorOf":
1067 {
1068 mirror.mirrorOf( interpolatedTrimmed( parser.nextText(), "mirrorOf" ) );
1069 break;
1070 }
1071 case "name":
1072 {
1073 mirror.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1074 break;
1075 }
1076 case "url":
1077 {
1078 mirror.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1079 break;
1080 }
1081 case "layout":
1082 {
1083 mirror.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
1084 break;
1085 }
1086 case "mirrorOfLayouts":
1087 {
1088 mirror.mirrorOfLayouts( interpolatedTrimmed( parser.nextText(), "mirrorOfLayouts" ) );
1089 break;
1090 }
1091 case "blocked":
1092 {
1093 mirror.blocked( getBooleanValue( interpolatedTrimmed( parser.nextText(), "blocked" ), "blocked", parser, "false" ) );
1094 break;
1095 }
1096 default:
1097 {
1098 checkUnknownElement( parser, strict );
1099 break;
1100 }
1101 }
1102 }
1103 return mirror.build();
1104 }
1105
1106 private Profile parseProfile( XmlPullParser parser, boolean strict )
1107 throws IOException, XmlPullParserException
1108 {
1109 String tagName = parser.getName();
1110 Profile.Builder profile = Profile.newBuilder( true );
1111 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1112 {
1113 String name = parser.getAttributeName( i );
1114 String value = parser.getAttributeValue( i );
1115 if ( name.indexOf( ':' ) >= 0 )
1116 {
1117
1118 }
1119 else
1120 {
1121 checkUnknownAttribute( parser, name, tagName, strict );
1122 }
1123 }
1124 Set<String> parsed = new HashSet<>();
1125 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1126 {
1127 String childName = checkDuplicate( parser.getName(), parser, parsed );
1128 switch ( childName )
1129 {
1130 case "id":
1131 {
1132 profile.id( interpolatedTrimmed( parser.nextText(), "id" ) );
1133 break;
1134 }
1135 case "activation":
1136 {
1137 profile.activation( parseActivation( parser, strict ) );
1138 break;
1139 }
1140 case "properties":
1141 {
1142 Map<String, String> properties = new LinkedHashMap<>();
1143 while ( parser.nextTag() == XmlPullParser.START_TAG )
1144 {
1145 String key = parser.getName();
1146 String value = parser.nextText().trim();
1147 properties.put( key, value );
1148 }
1149 profile.properties( properties );
1150 break;
1151 }
1152 case "repositories":
1153 {
1154 List<Repository> repositories = new ArrayList<>();
1155 while ( parser.nextTag() == XmlPullParser.START_TAG )
1156 {
1157 if ( "repository".equals( parser.getName() ) )
1158 {
1159 repositories.add( parseRepository( parser, strict ) );
1160 }
1161 else
1162 {
1163 checkUnknownElement( parser, strict );
1164 }
1165 }
1166 profile.repositories( repositories );
1167 break;
1168 }
1169 case "pluginRepositories":
1170 {
1171 List<Repository> pluginRepositories = new ArrayList<>();
1172 while ( parser.nextTag() == XmlPullParser.START_TAG )
1173 {
1174 if ( "pluginRepository".equals( parser.getName() ) )
1175 {
1176 pluginRepositories.add( parseRepository( parser, strict ) );
1177 }
1178 else
1179 {
1180 checkUnknownElement( parser, strict );
1181 }
1182 }
1183 profile.pluginRepositories( pluginRepositories );
1184 break;
1185 }
1186 default:
1187 {
1188 checkUnknownElement( parser, strict );
1189 break;
1190 }
1191 }
1192 }
1193 return profile.build();
1194 }
1195
1196 private Activation parseActivation( XmlPullParser parser, boolean strict )
1197 throws IOException, XmlPullParserException
1198 {
1199 String tagName = parser.getName();
1200 Activation.Builder activation = Activation.newBuilder( true );
1201 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1202 {
1203 String name = parser.getAttributeName( i );
1204 String value = parser.getAttributeValue( i );
1205 if ( name.indexOf( ':' ) >= 0 )
1206 {
1207
1208 }
1209 else
1210 {
1211 checkUnknownAttribute( parser, name, tagName, strict );
1212 }
1213 }
1214 Set<String> parsed = new HashSet<>();
1215 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1216 {
1217 String childName = checkDuplicate( parser.getName(), parser, parsed );
1218 switch ( childName )
1219 {
1220 case "activeByDefault":
1221 {
1222 activation.activeByDefault( getBooleanValue( interpolatedTrimmed( parser.nextText(), "activeByDefault" ), "activeByDefault", parser, "false" ) );
1223 break;
1224 }
1225 case "jdk":
1226 {
1227 activation.jdk( interpolatedTrimmed( parser.nextText(), "jdk" ) );
1228 break;
1229 }
1230 case "os":
1231 {
1232 activation.os( parseActivationOS( parser, strict ) );
1233 break;
1234 }
1235 case "property":
1236 {
1237 activation.property( parseActivationProperty( parser, strict ) );
1238 break;
1239 }
1240 case "file":
1241 {
1242 activation.file( parseActivationFile( parser, strict ) );
1243 break;
1244 }
1245 default:
1246 {
1247 checkUnknownElement( parser, strict );
1248 break;
1249 }
1250 }
1251 }
1252 return activation.build();
1253 }
1254
1255 private RepositoryBase parseRepositoryBase( XmlPullParser parser, boolean strict )
1256 throws IOException, XmlPullParserException
1257 {
1258 String tagName = parser.getName();
1259 RepositoryBase.Builder repositoryBase = RepositoryBase.newBuilder( true );
1260 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1261 {
1262 String name = parser.getAttributeName( i );
1263 String value = parser.getAttributeValue( i );
1264 if ( name.indexOf( ':' ) >= 0 )
1265 {
1266
1267 }
1268 else
1269 {
1270 checkUnknownAttribute( parser, name, tagName, strict );
1271 }
1272 }
1273 Set<String> parsed = new HashSet<>();
1274 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1275 {
1276 String childName = checkDuplicate( parser.getName(), parser, parsed );
1277 switch ( childName )
1278 {
1279 case "id":
1280 {
1281 repositoryBase.id( interpolatedTrimmed( parser.nextText(), "id" ) );
1282 break;
1283 }
1284 case "name":
1285 {
1286 repositoryBase.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1287 break;
1288 }
1289 case "url":
1290 {
1291 repositoryBase.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1292 break;
1293 }
1294 case "layout":
1295 {
1296 repositoryBase.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
1297 break;
1298 }
1299 default:
1300 {
1301 checkUnknownElement( parser, strict );
1302 break;
1303 }
1304 }
1305 }
1306 return repositoryBase.build();
1307 }
1308
1309 private Repository parseRepository( XmlPullParser parser, boolean strict )
1310 throws IOException, XmlPullParserException
1311 {
1312 String tagName = parser.getName();
1313 Repository.Builder repository = Repository.newBuilder( true );
1314 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1315 {
1316 String name = parser.getAttributeName( i );
1317 String value = parser.getAttributeValue( i );
1318 if ( name.indexOf( ':' ) >= 0 )
1319 {
1320
1321 }
1322 else
1323 {
1324 checkUnknownAttribute( parser, name, tagName, strict );
1325 }
1326 }
1327 Set<String> parsed = new HashSet<>();
1328 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1329 {
1330 String childName = checkDuplicate( parser.getName(), parser, parsed );
1331 switch ( childName )
1332 {
1333 case "id":
1334 {
1335 repository.id( interpolatedTrimmed( parser.nextText(), "id" ) );
1336 break;
1337 }
1338 case "name":
1339 {
1340 repository.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1341 break;
1342 }
1343 case "url":
1344 {
1345 repository.url( interpolatedTrimmed( parser.nextText(), "url" ) );
1346 break;
1347 }
1348 case "layout":
1349 {
1350 repository.layout( interpolatedTrimmed( parser.nextText(), "layout" ) );
1351 break;
1352 }
1353 case "releases":
1354 {
1355 repository.releases( parseRepositoryPolicy( parser, strict ) );
1356 break;
1357 }
1358 case "snapshots":
1359 {
1360 repository.snapshots( parseRepositoryPolicy( parser, strict ) );
1361 break;
1362 }
1363 default:
1364 {
1365 checkUnknownElement( parser, strict );
1366 break;
1367 }
1368 }
1369 }
1370 return repository.build();
1371 }
1372
1373 private RepositoryPolicy parseRepositoryPolicy( XmlPullParser parser, boolean strict )
1374 throws IOException, XmlPullParserException
1375 {
1376 String tagName = parser.getName();
1377 RepositoryPolicy.Builder repositoryPolicy = RepositoryPolicy.newBuilder( true );
1378 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1379 {
1380 String name = parser.getAttributeName( i );
1381 String value = parser.getAttributeValue( i );
1382 if ( name.indexOf( ':' ) >= 0 )
1383 {
1384
1385 }
1386 else
1387 {
1388 checkUnknownAttribute( parser, name, tagName, strict );
1389 }
1390 }
1391 Set<String> parsed = new HashSet<>();
1392 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1393 {
1394 String childName = checkDuplicate( parser.getName(), parser, parsed );
1395 switch ( childName )
1396 {
1397 case "enabled":
1398 {
1399 repositoryPolicy.enabled( getBooleanValue( interpolatedTrimmed( parser.nextText(), "enabled" ), "enabled", parser, "true" ) );
1400 break;
1401 }
1402 case "updatePolicy":
1403 {
1404 repositoryPolicy.updatePolicy( interpolatedTrimmed( parser.nextText(), "updatePolicy" ) );
1405 break;
1406 }
1407 case "checksumPolicy":
1408 {
1409 repositoryPolicy.checksumPolicy( interpolatedTrimmed( parser.nextText(), "checksumPolicy" ) );
1410 break;
1411 }
1412 default:
1413 {
1414 checkUnknownElement( parser, strict );
1415 break;
1416 }
1417 }
1418 }
1419 return repositoryPolicy.build();
1420 }
1421
1422 private ActivationProperty parseActivationProperty( XmlPullParser parser, boolean strict )
1423 throws IOException, XmlPullParserException
1424 {
1425 String tagName = parser.getName();
1426 ActivationProperty.Builder activationProperty = ActivationProperty.newBuilder( true );
1427 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1428 {
1429 String name = parser.getAttributeName( i );
1430 String value = parser.getAttributeValue( i );
1431 if ( name.indexOf( ':' ) >= 0 )
1432 {
1433
1434 }
1435 else
1436 {
1437 checkUnknownAttribute( parser, name, tagName, strict );
1438 }
1439 }
1440 Set<String> parsed = new HashSet<>();
1441 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1442 {
1443 String childName = checkDuplicate( parser.getName(), parser, parsed );
1444 switch ( childName )
1445 {
1446 case "name":
1447 {
1448 activationProperty.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1449 break;
1450 }
1451 case "value":
1452 {
1453 activationProperty.value( interpolatedTrimmed( parser.nextText(), "value" ) );
1454 break;
1455 }
1456 default:
1457 {
1458 checkUnknownElement( parser, strict );
1459 break;
1460 }
1461 }
1462 }
1463 return activationProperty.build();
1464 }
1465
1466 private ActivationOS parseActivationOS( XmlPullParser parser, boolean strict )
1467 throws IOException, XmlPullParserException
1468 {
1469 String tagName = parser.getName();
1470 ActivationOS.Builder activationOS = ActivationOS.newBuilder( true );
1471 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1472 {
1473 String name = parser.getAttributeName( i );
1474 String value = parser.getAttributeValue( i );
1475 if ( name.indexOf( ':' ) >= 0 )
1476 {
1477
1478 }
1479 else
1480 {
1481 checkUnknownAttribute( parser, name, tagName, strict );
1482 }
1483 }
1484 Set<String> parsed = new HashSet<>();
1485 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1486 {
1487 String childName = checkDuplicate( parser.getName(), parser, parsed );
1488 switch ( childName )
1489 {
1490 case "name":
1491 {
1492 activationOS.name( interpolatedTrimmed( parser.nextText(), "name" ) );
1493 break;
1494 }
1495 case "family":
1496 {
1497 activationOS.family( interpolatedTrimmed( parser.nextText(), "family" ) );
1498 break;
1499 }
1500 case "arch":
1501 {
1502 activationOS.arch( interpolatedTrimmed( parser.nextText(), "arch" ) );
1503 break;
1504 }
1505 case "version":
1506 {
1507 activationOS.version( interpolatedTrimmed( parser.nextText(), "version" ) );
1508 break;
1509 }
1510 default:
1511 {
1512 checkUnknownElement( parser, strict );
1513 break;
1514 }
1515 }
1516 }
1517 return activationOS.build();
1518 }
1519
1520 private ActivationFile parseActivationFile( XmlPullParser parser, boolean strict )
1521 throws IOException, XmlPullParserException
1522 {
1523 String tagName = parser.getName();
1524 ActivationFile.Builder activationFile = ActivationFile.newBuilder( true );
1525 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1526 {
1527 String name = parser.getAttributeName( i );
1528 String value = parser.getAttributeValue( i );
1529 if ( name.indexOf( ':' ) >= 0 )
1530 {
1531
1532 }
1533 else
1534 {
1535 checkUnknownAttribute( parser, name, tagName, strict );
1536 }
1537 }
1538 Set<String> parsed = new HashSet<>();
1539 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1540 {
1541 String childName = checkDuplicate( parser.getName(), parser, parsed );
1542 switch ( childName )
1543 {
1544 case "missing":
1545 {
1546 activationFile.missing( interpolatedTrimmed( parser.nextText(), "missing" ) );
1547 break;
1548 }
1549 case "exists":
1550 {
1551 activationFile.exists( interpolatedTrimmed( parser.nextText(), "exists" ) );
1552 break;
1553 }
1554 default:
1555 {
1556 checkUnknownElement( parser, strict );
1557 break;
1558 }
1559 }
1560 }
1561 return activationFile.build();
1562 }
1563
1564
1565 private String checkDuplicate( String tagName, XmlPullParser parser, Set<String> parsed )
1566 throws XmlPullParserException
1567 {
1568 return tagName;
1569 }
1570
1571
1572
1573
1574
1575
1576 public void setAddDefaultEntities( boolean addDefaultEntities )
1577 {
1578 this.addDefaultEntities = addDefaultEntities;
1579 }
1580
1581 public static interface ContentTransformer
1582 {
1583
1584
1585
1586
1587
1588
1589
1590 String transform( String source, String fieldName );
1591 }
1592
1593 }