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