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