1
2
3
4
5 package org.apache.maven.settings.io.xpp3;
6
7
8
9
10
11 import java.io.IOException;
12 import java.io.InputStream;
13 import java.io.Reader;
14 import java.text.DateFormat;
15 import java.util.Locale;
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.Xpp3DomBuilder;
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 public class SettingsXpp3Reader {
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58 private boolean addDefaultEntities = true;
59
60
61
62
63
64
65
66
67
68
69
70 public boolean getAddDefaultEntities()
71 {
72 return addDefaultEntities;
73 }
74
75
76
77
78
79
80
81
82
83
84 public boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
85 throws XmlPullParserException
86 {
87 return getBooleanValue( s, attribute, parser, null );
88 }
89
90
91
92
93
94
95
96
97
98
99
100 public boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
101 throws XmlPullParserException
102 {
103 if ( s != null && s.length() != 0 )
104 {
105 return Boolean.valueOf( s ).booleanValue();
106 }
107 if ( defaultValue != null )
108 {
109 return Boolean.valueOf( defaultValue ).booleanValue();
110 }
111 return false;
112 }
113
114
115
116
117
118
119
120
121
122
123
124 public byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
125 throws XmlPullParserException
126 {
127 if ( s != null )
128 {
129 try
130 {
131 return Byte.valueOf( s ).byteValue();
132 }
133 catch ( NumberFormatException e )
134 {
135 if ( strict )
136 {
137 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, null );
138 }
139 }
140 }
141 return 0;
142 }
143
144
145
146
147
148
149
150
151
152
153 public char getCharacterValue( String s, String attribute, XmlPullParser parser )
154 throws XmlPullParserException
155 {
156 if ( s != null )
157 {
158 return s.charAt( 0 );
159 }
160 return 0;
161 }
162
163
164
165
166
167
168
169
170
171
172 public java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
173 throws XmlPullParserException
174 {
175 return getDateValue( s, attribute, null, parser );
176 }
177
178
179
180
181
182
183
184
185
186
187
188 public java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
189 throws XmlPullParserException
190 {
191 if ( s != null )
192 {
193 if ( dateFormat == null )
194 {
195 return new java.util.Date( Long.valueOf( s ).longValue() );
196 }
197 else
198 {
199 DateFormat dateParser = new java.text.SimpleDateFormat( dateFormat, Locale.US );
200 try
201 {
202 return dateParser.parse( s );
203 }
204 catch ( java.text.ParseException e )
205 {
206 throw new XmlPullParserException( e.getMessage() );
207 }
208 }
209 }
210 return null;
211 }
212
213
214
215
216
217
218
219
220
221
222
223 public double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
224 throws XmlPullParserException
225 {
226 if ( s != null )
227 {
228 try
229 {
230 return Double.valueOf( s ).doubleValue();
231 }
232 catch ( NumberFormatException e )
233 {
234 if ( strict )
235 {
236 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
237 }
238 }
239 }
240 return 0;
241 }
242
243
244
245
246
247
248
249
250
251
252
253 public float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
254 throws XmlPullParserException
255 {
256 if ( s != null )
257 {
258 try
259 {
260 return Float.valueOf( s ).floatValue();
261 }
262 catch ( NumberFormatException e )
263 {
264 if ( strict )
265 {
266 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
267 }
268 }
269 }
270 return 0;
271 }
272
273
274
275
276
277
278
279
280
281
282
283 public int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
284 throws XmlPullParserException
285 {
286 if ( s != null )
287 {
288 try
289 {
290 return Integer.valueOf( s ).intValue();
291 }
292 catch ( NumberFormatException e )
293 {
294 if ( strict )
295 {
296 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, null );
297 }
298 }
299 }
300 return 0;
301 }
302
303
304
305
306
307
308
309
310
311
312
313 public long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
314 throws XmlPullParserException
315 {
316 if ( s != null )
317 {
318 try
319 {
320 return Long.valueOf( s ).longValue();
321 }
322 catch ( NumberFormatException e )
323 {
324 if ( strict )
325 {
326 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, null );
327 }
328 }
329 }
330 return 0;
331 }
332
333
334
335
336
337
338
339
340
341
342
343 public String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
344 throws XmlPullParserException
345 {
346 if ( s == null )
347 {
348 if ( strict )
349 {
350 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
351 }
352 }
353 return s;
354 }
355
356
357
358
359
360
361
362
363
364
365
366 public short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
367 throws XmlPullParserException
368 {
369 if ( s != null )
370 {
371 try
372 {
373 return Short.valueOf( s ).shortValue();
374 }
375 catch ( NumberFormatException e )
376 {
377 if ( strict )
378 {
379 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, null );
380 }
381 }
382 }
383 return 0;
384 }
385
386
387
388
389
390
391
392 public String getTrimmedValue( String s )
393 {
394 if ( s != null )
395 {
396 s = s.trim();
397 }
398 return s;
399 }
400
401
402
403
404
405
406
407
408
409
410
411 private Activation parseActivation( String tagName, XmlPullParser parser, boolean strict )
412 throws IOException, XmlPullParserException
413 {
414 Activation activation = new Activation();
415 java.util.Set parsed = new java.util.HashSet();
416 while ( parser.nextTag() == XmlPullParser.START_TAG )
417 {
418 if ( parser.getName().equals( "activeByDefault" ) )
419 {
420 if ( parsed.contains( "activeByDefault" ) )
421 {
422 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
423 }
424 parsed.add( "activeByDefault" );
425 activation.setActiveByDefault( getBooleanValue( getTrimmedValue( parser.nextText()), "activeByDefault", parser, "false" ) );
426 }
427 else if ( parser.getName().equals( "jdk" ) )
428 {
429 if ( parsed.contains( "jdk" ) )
430 {
431 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
432 }
433 parsed.add( "jdk" );
434 activation.setJdk( getTrimmedValue( parser.nextText()) );
435 }
436 else if ( parser.getName().equals( "os" ) )
437 {
438 if ( parsed.contains( "os" ) )
439 {
440 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
441 }
442 parsed.add( "os" );
443 activation.setOs( parseActivationOS( "os", parser, strict ) );
444 }
445 else if ( parser.getName().equals( "property" ) )
446 {
447 if ( parsed.contains( "property" ) )
448 {
449 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
450 }
451 parsed.add( "property" );
452 activation.setProperty( parseActivationProperty( "property", parser, strict ) );
453 }
454 else if ( parser.getName().equals( "file" ) )
455 {
456 if ( parsed.contains( "file" ) )
457 {
458 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
459 }
460 parsed.add( "file" );
461 activation.setFile( parseActivationFile( "file", parser, strict ) );
462 }
463 else
464 {
465 if ( strict )
466 {
467 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
468 }
469 else
470 {
471
472 while ( parser.next() != XmlPullParser.END_TAG ) {}
473 }
474 }
475 }
476 return activation;
477 }
478
479
480
481
482
483
484
485
486
487
488
489 private ActivationFile parseActivationFile( String tagName, XmlPullParser parser, boolean strict )
490 throws IOException, XmlPullParserException
491 {
492 ActivationFile activationFile = new ActivationFile();
493 java.util.Set parsed = new java.util.HashSet();
494 while ( parser.nextTag() == XmlPullParser.START_TAG )
495 {
496 if ( parser.getName().equals( "missing" ) )
497 {
498 if ( parsed.contains( "missing" ) )
499 {
500 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
501 }
502 parsed.add( "missing" );
503 activationFile.setMissing( getTrimmedValue( parser.nextText()) );
504 }
505 else if ( parser.getName().equals( "exists" ) )
506 {
507 if ( parsed.contains( "exists" ) )
508 {
509 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
510 }
511 parsed.add( "exists" );
512 activationFile.setExists( getTrimmedValue( parser.nextText()) );
513 }
514 else
515 {
516 if ( strict )
517 {
518 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
519 }
520 else
521 {
522
523 while ( parser.next() != XmlPullParser.END_TAG ) {}
524 }
525 }
526 }
527 return activationFile;
528 }
529
530
531
532
533
534
535
536
537
538
539
540 private ActivationOS parseActivationOS( String tagName, XmlPullParser parser, boolean strict )
541 throws IOException, XmlPullParserException
542 {
543 ActivationOS activationOS = new ActivationOS();
544 java.util.Set parsed = new java.util.HashSet();
545 while ( parser.nextTag() == XmlPullParser.START_TAG )
546 {
547 if ( parser.getName().equals( "name" ) )
548 {
549 if ( parsed.contains( "name" ) )
550 {
551 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
552 }
553 parsed.add( "name" );
554 activationOS.setName( getTrimmedValue( parser.nextText()) );
555 }
556 else if ( parser.getName().equals( "family" ) )
557 {
558 if ( parsed.contains( "family" ) )
559 {
560 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
561 }
562 parsed.add( "family" );
563 activationOS.setFamily( getTrimmedValue( parser.nextText()) );
564 }
565 else if ( parser.getName().equals( "arch" ) )
566 {
567 if ( parsed.contains( "arch" ) )
568 {
569 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
570 }
571 parsed.add( "arch" );
572 activationOS.setArch( getTrimmedValue( parser.nextText()) );
573 }
574 else if ( parser.getName().equals( "version" ) )
575 {
576 if ( parsed.contains( "version" ) )
577 {
578 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
579 }
580 parsed.add( "version" );
581 activationOS.setVersion( getTrimmedValue( parser.nextText()) );
582 }
583 else
584 {
585 if ( strict )
586 {
587 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
588 }
589 else
590 {
591
592 while ( parser.next() != XmlPullParser.END_TAG ) {}
593 }
594 }
595 }
596 return activationOS;
597 }
598
599
600
601
602
603
604
605
606
607
608
609 private ActivationProperty parseActivationProperty( String tagName, XmlPullParser parser, boolean strict )
610 throws IOException, XmlPullParserException
611 {
612 ActivationProperty activationProperty = new ActivationProperty();
613 java.util.Set parsed = new java.util.HashSet();
614 while ( parser.nextTag() == XmlPullParser.START_TAG )
615 {
616 if ( parser.getName().equals( "name" ) )
617 {
618 if ( parsed.contains( "name" ) )
619 {
620 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
621 }
622 parsed.add( "name" );
623 activationProperty.setName( getTrimmedValue( parser.nextText()) );
624 }
625 else if ( parser.getName().equals( "value" ) )
626 {
627 if ( parsed.contains( "value" ) )
628 {
629 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
630 }
631 parsed.add( "value" );
632 activationProperty.setValue( getTrimmedValue( parser.nextText()) );
633 }
634 else
635 {
636 if ( strict )
637 {
638 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
639 }
640 else
641 {
642
643 while ( parser.next() != XmlPullParser.END_TAG ) {}
644 }
645 }
646 }
647 return activationProperty;
648 }
649
650
651
652
653
654
655
656
657
658
659
660 private IdentifiableBase parseIdentifiableBase( String tagName, XmlPullParser parser, boolean strict )
661 throws IOException, XmlPullParserException
662 {
663 IdentifiableBase identifiableBase = new IdentifiableBase();
664 java.util.Set parsed = new java.util.HashSet();
665 while ( parser.nextTag() == XmlPullParser.START_TAG )
666 {
667 if ( parser.getName().equals( "id" ) )
668 {
669 if ( parsed.contains( "id" ) )
670 {
671 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
672 }
673 parsed.add( "id" );
674 identifiableBase.setId( getTrimmedValue( parser.nextText()) );
675 }
676 else
677 {
678 if ( strict )
679 {
680 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
681 }
682 else
683 {
684
685 while ( parser.next() != XmlPullParser.END_TAG ) {}
686 }
687 }
688 }
689 return identifiableBase;
690 }
691
692
693
694
695
696
697
698
699
700
701
702 private Mirror parseMirror( String tagName, XmlPullParser parser, boolean strict )
703 throws IOException, XmlPullParserException
704 {
705 Mirror mirror = new Mirror();
706 java.util.Set parsed = new java.util.HashSet();
707 while ( parser.nextTag() == XmlPullParser.START_TAG )
708 {
709 if ( parser.getName().equals( "mirrorOf" ) )
710 {
711 if ( parsed.contains( "mirrorOf" ) )
712 {
713 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
714 }
715 parsed.add( "mirrorOf" );
716 mirror.setMirrorOf( getTrimmedValue( parser.nextText()) );
717 }
718 else if ( parser.getName().equals( "name" ) )
719 {
720 if ( parsed.contains( "name" ) )
721 {
722 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
723 }
724 parsed.add( "name" );
725 mirror.setName( getTrimmedValue( parser.nextText()) );
726 }
727 else if ( parser.getName().equals( "url" ) )
728 {
729 if ( parsed.contains( "url" ) )
730 {
731 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
732 }
733 parsed.add( "url" );
734 mirror.setUrl( getTrimmedValue( parser.nextText()) );
735 }
736 else if ( parser.getName().equals( "id" ) )
737 {
738 if ( parsed.contains( "id" ) )
739 {
740 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
741 }
742 parsed.add( "id" );
743 mirror.setId( getTrimmedValue( parser.nextText()) );
744 }
745 else
746 {
747 if ( strict )
748 {
749 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
750 }
751 else
752 {
753
754 while ( parser.next() != XmlPullParser.END_TAG ) {}
755 }
756 }
757 }
758 return mirror;
759 }
760
761
762
763
764
765
766
767
768
769
770
771 private Profile parseProfile( String tagName, XmlPullParser parser, boolean strict )
772 throws IOException, XmlPullParserException
773 {
774 Profile profile = new Profile();
775 java.util.Set parsed = new java.util.HashSet();
776 while ( parser.nextTag() == XmlPullParser.START_TAG )
777 {
778 if ( parser.getName().equals( "activation" ) )
779 {
780 if ( parsed.contains( "activation" ) )
781 {
782 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
783 }
784 parsed.add( "activation" );
785 profile.setActivation( parseActivation( "activation", parser, strict ) );
786 }
787 else if ( parser.getName().equals( "properties" ) )
788 {
789 if ( parsed.contains( "properties" ) )
790 {
791 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
792 }
793 parsed.add( "properties" );
794 while ( parser.nextTag() == XmlPullParser.START_TAG )
795 {
796 String key = parser.getName();
797 String value = parser.nextText().trim();
798 profile.addProperty( key, value );
799 }
800 }
801 else if ( parser.getName().equals( "repositories" ) )
802 {
803 if ( parsed.contains( "repositories" ) )
804 {
805 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
806 }
807 parsed.add( "repositories" );
808 java.util.List repositories = new java.util.ArrayList();
809 profile.setRepositories( repositories );
810 while ( parser.nextTag() == XmlPullParser.START_TAG )
811 {
812 if ( parser.getName().equals( "repository" ) )
813 {
814 repositories.add( parseRepository( "repository", parser, strict ) );
815 }
816 else if ( strict )
817 {
818 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
819 }
820 else
821 {
822
823 while ( parser.next() != XmlPullParser.END_TAG ) {}
824 }
825 }
826 }
827 else if ( parser.getName().equals( "pluginRepositories" ) )
828 {
829 if ( parsed.contains( "pluginRepositories" ) )
830 {
831 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
832 }
833 parsed.add( "pluginRepositories" );
834 java.util.List pluginRepositories = new java.util.ArrayList();
835 profile.setPluginRepositories( pluginRepositories );
836 while ( parser.nextTag() == XmlPullParser.START_TAG )
837 {
838 if ( parser.getName().equals( "pluginRepository" ) )
839 {
840 pluginRepositories.add( parseRepository( "pluginRepository", parser, strict ) );
841 }
842 else if ( strict )
843 {
844 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
845 }
846 else
847 {
848
849 while ( parser.next() != XmlPullParser.END_TAG ) {}
850 }
851 }
852 }
853 else if ( parser.getName().equals( "id" ) )
854 {
855 if ( parsed.contains( "id" ) )
856 {
857 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
858 }
859 parsed.add( "id" );
860 profile.setId( getTrimmedValue( parser.nextText()) );
861 }
862 else
863 {
864 if ( strict )
865 {
866 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
867 }
868 else
869 {
870
871 while ( parser.next() != XmlPullParser.END_TAG ) {}
872 }
873 }
874 }
875 return profile;
876 }
877
878
879
880
881
882
883
884
885
886
887
888 private Proxy parseProxy( String tagName, XmlPullParser parser, boolean strict )
889 throws IOException, XmlPullParserException
890 {
891 Proxy proxy = new Proxy();
892 java.util.Set parsed = new java.util.HashSet();
893 while ( parser.nextTag() == XmlPullParser.START_TAG )
894 {
895 if ( parser.getName().equals( "active" ) )
896 {
897 if ( parsed.contains( "active" ) )
898 {
899 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
900 }
901 parsed.add( "active" );
902 proxy.setActive( getBooleanValue( getTrimmedValue( parser.nextText()), "active", parser, "true" ) );
903 }
904 else if ( parser.getName().equals( "protocol" ) )
905 {
906 if ( parsed.contains( "protocol" ) )
907 {
908 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
909 }
910 parsed.add( "protocol" );
911 proxy.setProtocol( getTrimmedValue( parser.nextText()) );
912 }
913 else if ( parser.getName().equals( "username" ) )
914 {
915 if ( parsed.contains( "username" ) )
916 {
917 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
918 }
919 parsed.add( "username" );
920 proxy.setUsername( getTrimmedValue( parser.nextText()) );
921 }
922 else if ( parser.getName().equals( "password" ) )
923 {
924 if ( parsed.contains( "password" ) )
925 {
926 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
927 }
928 parsed.add( "password" );
929 proxy.setPassword( getTrimmedValue( parser.nextText()) );
930 }
931 else if ( parser.getName().equals( "port" ) )
932 {
933 if ( parsed.contains( "port" ) )
934 {
935 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
936 }
937 parsed.add( "port" );
938 proxy.setPort( getIntegerValue( getTrimmedValue( parser.nextText()), "port", parser, strict ) );
939 }
940 else if ( parser.getName().equals( "host" ) )
941 {
942 if ( parsed.contains( "host" ) )
943 {
944 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
945 }
946 parsed.add( "host" );
947 proxy.setHost( getTrimmedValue( parser.nextText()) );
948 }
949 else if ( parser.getName().equals( "nonProxyHosts" ) )
950 {
951 if ( parsed.contains( "nonProxyHosts" ) )
952 {
953 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
954 }
955 parsed.add( "nonProxyHosts" );
956 proxy.setNonProxyHosts( getTrimmedValue( parser.nextText()) );
957 }
958 else if ( parser.getName().equals( "id" ) )
959 {
960 if ( parsed.contains( "id" ) )
961 {
962 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
963 }
964 parsed.add( "id" );
965 proxy.setId( getTrimmedValue( parser.nextText()) );
966 }
967 else
968 {
969 if ( strict )
970 {
971 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
972 }
973 else
974 {
975
976 while ( parser.next() != XmlPullParser.END_TAG ) {}
977 }
978 }
979 }
980 return proxy;
981 }
982
983
984
985
986
987
988
989
990
991
992
993 private Repository parseRepository( String tagName, XmlPullParser parser, boolean strict )
994 throws IOException, XmlPullParserException
995 {
996 Repository repository = new Repository();
997 java.util.Set parsed = new java.util.HashSet();
998 while ( parser.nextTag() == XmlPullParser.START_TAG )
999 {
1000 if ( parser.getName().equals( "releases" ) )
1001 {
1002 if ( parsed.contains( "releases" ) )
1003 {
1004 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1005 }
1006 parsed.add( "releases" );
1007 repository.setReleases( parseRepositoryPolicy( "releases", parser, strict ) );
1008 }
1009 else if ( parser.getName().equals( "snapshots" ) )
1010 {
1011 if ( parsed.contains( "snapshots" ) )
1012 {
1013 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1014 }
1015 parsed.add( "snapshots" );
1016 repository.setSnapshots( parseRepositoryPolicy( "snapshots", parser, strict ) );
1017 }
1018 else if ( parser.getName().equals( "id" ) )
1019 {
1020 if ( parsed.contains( "id" ) )
1021 {
1022 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1023 }
1024 parsed.add( "id" );
1025 repository.setId( getTrimmedValue( parser.nextText()) );
1026 }
1027 else if ( parser.getName().equals( "name" ) )
1028 {
1029 if ( parsed.contains( "name" ) )
1030 {
1031 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1032 }
1033 parsed.add( "name" );
1034 repository.setName( getTrimmedValue( parser.nextText()) );
1035 }
1036 else if ( parser.getName().equals( "url" ) )
1037 {
1038 if ( parsed.contains( "url" ) )
1039 {
1040 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1041 }
1042 parsed.add( "url" );
1043 repository.setUrl( getTrimmedValue( parser.nextText()) );
1044 }
1045 else if ( parser.getName().equals( "layout" ) )
1046 {
1047 if ( parsed.contains( "layout" ) )
1048 {
1049 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1050 }
1051 parsed.add( "layout" );
1052 repository.setLayout( getTrimmedValue( parser.nextText()) );
1053 }
1054 else
1055 {
1056 if ( strict )
1057 {
1058 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1059 }
1060 else
1061 {
1062
1063 while ( parser.next() != XmlPullParser.END_TAG ) {}
1064 }
1065 }
1066 }
1067 return repository;
1068 }
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080 private RepositoryBase parseRepositoryBase( String tagName, XmlPullParser parser, boolean strict )
1081 throws IOException, XmlPullParserException
1082 {
1083 RepositoryBase repositoryBase = new RepositoryBase();
1084 java.util.Set parsed = new java.util.HashSet();
1085 while ( parser.nextTag() == XmlPullParser.START_TAG )
1086 {
1087 if ( parser.getName().equals( "id" ) )
1088 {
1089 if ( parsed.contains( "id" ) )
1090 {
1091 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1092 }
1093 parsed.add( "id" );
1094 repositoryBase.setId( getTrimmedValue( parser.nextText()) );
1095 }
1096 else if ( parser.getName().equals( "name" ) )
1097 {
1098 if ( parsed.contains( "name" ) )
1099 {
1100 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1101 }
1102 parsed.add( "name" );
1103 repositoryBase.setName( getTrimmedValue( parser.nextText()) );
1104 }
1105 else if ( parser.getName().equals( "url" ) )
1106 {
1107 if ( parsed.contains( "url" ) )
1108 {
1109 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1110 }
1111 parsed.add( "url" );
1112 repositoryBase.setUrl( getTrimmedValue( parser.nextText()) );
1113 }
1114 else if ( parser.getName().equals( "layout" ) )
1115 {
1116 if ( parsed.contains( "layout" ) )
1117 {
1118 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1119 }
1120 parsed.add( "layout" );
1121 repositoryBase.setLayout( getTrimmedValue( parser.nextText()) );
1122 }
1123 else
1124 {
1125 if ( strict )
1126 {
1127 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1128 }
1129 else
1130 {
1131
1132 while ( parser.next() != XmlPullParser.END_TAG ) {}
1133 }
1134 }
1135 }
1136 return repositoryBase;
1137 }
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149 private RepositoryPolicy parseRepositoryPolicy( String tagName, XmlPullParser parser, boolean strict )
1150 throws IOException, XmlPullParserException
1151 {
1152 RepositoryPolicy repositoryPolicy = new RepositoryPolicy();
1153 java.util.Set parsed = new java.util.HashSet();
1154 while ( parser.nextTag() == XmlPullParser.START_TAG )
1155 {
1156 if ( parser.getName().equals( "enabled" ) )
1157 {
1158 if ( parsed.contains( "enabled" ) )
1159 {
1160 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1161 }
1162 parsed.add( "enabled" );
1163 repositoryPolicy.setEnabled( getBooleanValue( getTrimmedValue( parser.nextText()), "enabled", parser, "true" ) );
1164 }
1165 else if ( parser.getName().equals( "updatePolicy" ) )
1166 {
1167 if ( parsed.contains( "updatePolicy" ) )
1168 {
1169 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1170 }
1171 parsed.add( "updatePolicy" );
1172 repositoryPolicy.setUpdatePolicy( getTrimmedValue( parser.nextText()) );
1173 }
1174 else if ( parser.getName().equals( "checksumPolicy" ) )
1175 {
1176 if ( parsed.contains( "checksumPolicy" ) )
1177 {
1178 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1179 }
1180 parsed.add( "checksumPolicy" );
1181 repositoryPolicy.setChecksumPolicy( getTrimmedValue( parser.nextText()) );
1182 }
1183 else
1184 {
1185 if ( strict )
1186 {
1187 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1188 }
1189 else
1190 {
1191
1192 while ( parser.next() != XmlPullParser.END_TAG ) {}
1193 }
1194 }
1195 }
1196 return repositoryPolicy;
1197 }
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209 private Server parseServer( String tagName, XmlPullParser parser, boolean strict )
1210 throws IOException, XmlPullParserException
1211 {
1212 Server server = new Server();
1213 java.util.Set parsed = new java.util.HashSet();
1214 while ( parser.nextTag() == XmlPullParser.START_TAG )
1215 {
1216 if ( parser.getName().equals( "username" ) )
1217 {
1218 if ( parsed.contains( "username" ) )
1219 {
1220 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1221 }
1222 parsed.add( "username" );
1223 server.setUsername( getTrimmedValue( parser.nextText()) );
1224 }
1225 else if ( parser.getName().equals( "password" ) )
1226 {
1227 if ( parsed.contains( "password" ) )
1228 {
1229 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1230 }
1231 parsed.add( "password" );
1232 server.setPassword( getTrimmedValue( parser.nextText()) );
1233 }
1234 else if ( parser.getName().equals( "privateKey" ) )
1235 {
1236 if ( parsed.contains( "privateKey" ) )
1237 {
1238 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1239 }
1240 parsed.add( "privateKey" );
1241 server.setPrivateKey( getTrimmedValue( parser.nextText()) );
1242 }
1243 else if ( parser.getName().equals( "passphrase" ) )
1244 {
1245 if ( parsed.contains( "passphrase" ) )
1246 {
1247 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1248 }
1249 parsed.add( "passphrase" );
1250 server.setPassphrase( getTrimmedValue( parser.nextText()) );
1251 }
1252 else if ( parser.getName().equals( "filePermissions" ) )
1253 {
1254 if ( parsed.contains( "filePermissions" ) )
1255 {
1256 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1257 }
1258 parsed.add( "filePermissions" );
1259 server.setFilePermissions( getTrimmedValue( parser.nextText()) );
1260 }
1261 else if ( parser.getName().equals( "directoryPermissions" ) )
1262 {
1263 if ( parsed.contains( "directoryPermissions" ) )
1264 {
1265 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1266 }
1267 parsed.add( "directoryPermissions" );
1268 server.setDirectoryPermissions( getTrimmedValue( parser.nextText()) );
1269 }
1270 else if ( parser.getName().equals( "configuration" ) )
1271 {
1272 if ( parsed.contains( "configuration" ) )
1273 {
1274 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1275 }
1276 parsed.add( "configuration" );
1277 server.setConfiguration( Xpp3DomBuilder.build( parser ) );
1278 }
1279 else if ( parser.getName().equals( "id" ) )
1280 {
1281 if ( parsed.contains( "id" ) )
1282 {
1283 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1284 }
1285 parsed.add( "id" );
1286 server.setId( getTrimmedValue( parser.nextText()) );
1287 }
1288 else
1289 {
1290 if ( strict )
1291 {
1292 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1293 }
1294 else
1295 {
1296
1297 while ( parser.next() != XmlPullParser.END_TAG ) {}
1298 }
1299 }
1300 }
1301 return server;
1302 }
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314 private Settings parseSettings( String tagName, XmlPullParser parser, boolean strict )
1315 throws IOException, XmlPullParserException
1316 {
1317 Settings settings = new Settings();
1318 java.util.Set parsed = new java.util.HashSet();
1319 int eventType = parser.getEventType();
1320 boolean foundRoot = false;
1321 while ( eventType != XmlPullParser.END_DOCUMENT )
1322 {
1323 if ( eventType == XmlPullParser.START_TAG )
1324 {
1325 if ( parser.getName().equals( tagName ) )
1326 {
1327 foundRoot = true;
1328 }
1329 else if ( parser.getName().equals( "localRepository" ) )
1330 {
1331 if ( parsed.contains( "localRepository" ) )
1332 {
1333 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1334 }
1335 parsed.add( "localRepository" );
1336 settings.setLocalRepository( getTrimmedValue( parser.nextText()) );
1337 }
1338 else if ( parser.getName().equals( "interactiveMode" ) )
1339 {
1340 if ( parsed.contains( "interactiveMode" ) )
1341 {
1342 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1343 }
1344 parsed.add( "interactiveMode" );
1345 settings.setInteractiveMode( getBooleanValue( getTrimmedValue( parser.nextText()), "interactiveMode", parser, "true" ) );
1346 }
1347 else if ( parser.getName().equals( "usePluginRegistry" ) )
1348 {
1349 if ( parsed.contains( "usePluginRegistry" ) )
1350 {
1351 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1352 }
1353 parsed.add( "usePluginRegistry" );
1354 settings.setUsePluginRegistry( getBooleanValue( getTrimmedValue( parser.nextText()), "usePluginRegistry", parser, "false" ) );
1355 }
1356 else if ( parser.getName().equals( "offline" ) )
1357 {
1358 if ( parsed.contains( "offline" ) )
1359 {
1360 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1361 }
1362 parsed.add( "offline" );
1363 settings.setOffline( getBooleanValue( getTrimmedValue( parser.nextText()), "offline", parser, "false" ) );
1364 }
1365 else if ( parser.getName().equals( "proxies" ) )
1366 {
1367 if ( parsed.contains( "proxies" ) )
1368 {
1369 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1370 }
1371 parsed.add( "proxies" );
1372 java.util.List proxies = new java.util.ArrayList();
1373 settings.setProxies( proxies );
1374 while ( parser.nextTag() == XmlPullParser.START_TAG )
1375 {
1376 if ( parser.getName().equals( "proxy" ) )
1377 {
1378 proxies.add( parseProxy( "proxy", parser, strict ) );
1379 }
1380 else if ( strict )
1381 {
1382 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1383 }
1384 else
1385 {
1386
1387 while ( parser.next() != XmlPullParser.END_TAG ) {}
1388 }
1389 }
1390 }
1391 else if ( parser.getName().equals( "servers" ) )
1392 {
1393 if ( parsed.contains( "servers" ) )
1394 {
1395 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1396 }
1397 parsed.add( "servers" );
1398 java.util.List servers = new java.util.ArrayList();
1399 settings.setServers( servers );
1400 while ( parser.nextTag() == XmlPullParser.START_TAG )
1401 {
1402 if ( parser.getName().equals( "server" ) )
1403 {
1404 servers.add( parseServer( "server", parser, strict ) );
1405 }
1406 else if ( strict )
1407 {
1408 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1409 }
1410 else
1411 {
1412
1413 while ( parser.next() != XmlPullParser.END_TAG ) {}
1414 }
1415 }
1416 }
1417 else if ( parser.getName().equals( "mirrors" ) )
1418 {
1419 if ( parsed.contains( "mirrors" ) )
1420 {
1421 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1422 }
1423 parsed.add( "mirrors" );
1424 java.util.List mirrors = new java.util.ArrayList();
1425 settings.setMirrors( mirrors );
1426 while ( parser.nextTag() == XmlPullParser.START_TAG )
1427 {
1428 if ( parser.getName().equals( "mirror" ) )
1429 {
1430 mirrors.add( parseMirror( "mirror", parser, strict ) );
1431 }
1432 else if ( strict )
1433 {
1434 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1435 }
1436 else
1437 {
1438
1439 while ( parser.next() != XmlPullParser.END_TAG ) {}
1440 }
1441 }
1442 }
1443 else if ( parser.getName().equals( "profiles" ) )
1444 {
1445 if ( parsed.contains( "profiles" ) )
1446 {
1447 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1448 }
1449 parsed.add( "profiles" );
1450 java.util.List profiles = new java.util.ArrayList();
1451 settings.setProfiles( profiles );
1452 while ( parser.nextTag() == XmlPullParser.START_TAG )
1453 {
1454 if ( parser.getName().equals( "profile" ) )
1455 {
1456 profiles.add( parseProfile( "profile", parser, strict ) );
1457 }
1458 else if ( strict )
1459 {
1460 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1461 }
1462 else
1463 {
1464
1465 while ( parser.next() != XmlPullParser.END_TAG ) {}
1466 }
1467 }
1468 }
1469 else if ( parser.getName().equals( "activeProfiles" ) )
1470 {
1471 if ( parsed.contains( "activeProfiles" ) )
1472 {
1473 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1474 }
1475 parsed.add( "activeProfiles" );
1476 java.util.List activeProfiles = new java.util.ArrayList();
1477 settings.setActiveProfiles( activeProfiles );
1478 while ( parser.nextTag() == XmlPullParser.START_TAG )
1479 {
1480 if ( parser.getName().equals( "activeProfile" ) )
1481 {
1482 activeProfiles.add( getTrimmedValue( parser.nextText()) );
1483 }
1484 else if ( strict )
1485 {
1486 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1487 }
1488 else
1489 {
1490
1491 while ( parser.next() != XmlPullParser.END_TAG ) {}
1492 }
1493 }
1494 }
1495 else if ( parser.getName().equals( "pluginGroups" ) )
1496 {
1497 if ( parsed.contains( "pluginGroups" ) )
1498 {
1499 throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1500 }
1501 parsed.add( "pluginGroups" );
1502 java.util.List pluginGroups = new java.util.ArrayList();
1503 settings.setPluginGroups( pluginGroups );
1504 while ( parser.nextTag() == XmlPullParser.START_TAG )
1505 {
1506 if ( parser.getName().equals( "pluginGroup" ) )
1507 {
1508 pluginGroups.add( getTrimmedValue( parser.nextText()) );
1509 }
1510 else if ( strict )
1511 {
1512 throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1513 }
1514 else
1515 {
1516
1517 while ( parser.next() != XmlPullParser.END_TAG ) {}
1518 }
1519 }
1520 }
1521 else if ( strict )
1522 {
1523 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1524 }
1525 }
1526 eventType = parser.next();
1527 }
1528 return settings;
1529 }
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541 private TrackableBase parseTrackableBase( String tagName, XmlPullParser parser, boolean strict )
1542 throws IOException, XmlPullParserException
1543 {
1544 TrackableBase trackableBase = new TrackableBase();
1545 java.util.Set parsed = new java.util.HashSet();
1546 while ( parser.nextTag() == XmlPullParser.START_TAG )
1547 {
1548 if ( strict )
1549 {
1550 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1551 }
1552 else
1553 {
1554
1555 while ( parser.next() != XmlPullParser.END_TAG ) {}
1556 }
1557 }
1558 return trackableBase;
1559 }
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570 public Settings read( Reader reader, boolean strict )
1571 throws IOException, XmlPullParserException
1572 {
1573 XmlPullParser parser = new MXParser();
1574
1575 parser.setInput( reader );
1576
1577 if ( addDefaultEntities )
1578 {
1579
1580
1581
1582
1583 parser.defineEntityReplacementText( "nbsp", "\u00a0" );
1584 parser.defineEntityReplacementText( "iexcl", "\u00a1" );
1585 parser.defineEntityReplacementText( "cent", "\u00a2" );
1586 parser.defineEntityReplacementText( "pound", "\u00a3" );
1587 parser.defineEntityReplacementText( "curren", "\u00a4" );
1588 parser.defineEntityReplacementText( "yen", "\u00a5" );
1589 parser.defineEntityReplacementText( "brvbar", "\u00a6" );
1590 parser.defineEntityReplacementText( "sect", "\u00a7" );
1591 parser.defineEntityReplacementText( "uml", "\u00a8" );
1592 parser.defineEntityReplacementText( "copy", "\u00a9" );
1593 parser.defineEntityReplacementText( "ordf", "\u00aa" );
1594 parser.defineEntityReplacementText( "laquo", "\u00ab" );
1595 parser.defineEntityReplacementText( "not", "\u00ac" );
1596 parser.defineEntityReplacementText( "shy", "\u00ad" );
1597 parser.defineEntityReplacementText( "reg", "\u00ae" );
1598 parser.defineEntityReplacementText( "macr", "\u00af" );
1599 parser.defineEntityReplacementText( "deg", "\u00b0" );
1600 parser.defineEntityReplacementText( "plusmn", "\u00b1" );
1601 parser.defineEntityReplacementText( "sup2", "\u00b2" );
1602 parser.defineEntityReplacementText( "sup3", "\u00b3" );
1603 parser.defineEntityReplacementText( "acute", "\u00b4" );
1604 parser.defineEntityReplacementText( "micro", "\u00b5" );
1605 parser.defineEntityReplacementText( "para", "\u00b6" );
1606 parser.defineEntityReplacementText( "middot", "\u00b7" );
1607 parser.defineEntityReplacementText( "cedil", "\u00b8" );
1608 parser.defineEntityReplacementText( "sup1", "\u00b9" );
1609 parser.defineEntityReplacementText( "ordm", "\u00ba" );
1610 parser.defineEntityReplacementText( "raquo", "\u00bb" );
1611 parser.defineEntityReplacementText( "frac14", "\u00bc" );
1612 parser.defineEntityReplacementText( "frac12", "\u00bd" );
1613 parser.defineEntityReplacementText( "frac34", "\u00be" );
1614 parser.defineEntityReplacementText( "iquest", "\u00bf" );
1615 parser.defineEntityReplacementText( "Agrave", "\u00c0" );
1616 parser.defineEntityReplacementText( "Aacute", "\u00c1" );
1617 parser.defineEntityReplacementText( "Acirc", "\u00c2" );
1618 parser.defineEntityReplacementText( "Atilde", "\u00c3" );
1619 parser.defineEntityReplacementText( "Auml", "\u00c4" );
1620 parser.defineEntityReplacementText( "Aring", "\u00c5" );
1621 parser.defineEntityReplacementText( "AElig", "\u00c6" );
1622 parser.defineEntityReplacementText( "Ccedil", "\u00c7" );
1623 parser.defineEntityReplacementText( "Egrave", "\u00c8" );
1624 parser.defineEntityReplacementText( "Eacute", "\u00c9" );
1625 parser.defineEntityReplacementText( "Ecirc", "\u00ca" );
1626 parser.defineEntityReplacementText( "Euml", "\u00cb" );
1627 parser.defineEntityReplacementText( "Igrave", "\u00cc" );
1628 parser.defineEntityReplacementText( "Iacute", "\u00cd" );
1629 parser.defineEntityReplacementText( "Icirc", "\u00ce" );
1630 parser.defineEntityReplacementText( "Iuml", "\u00cf" );
1631 parser.defineEntityReplacementText( "ETH", "\u00d0" );
1632 parser.defineEntityReplacementText( "Ntilde", "\u00d1" );
1633 parser.defineEntityReplacementText( "Ograve", "\u00d2" );
1634 parser.defineEntityReplacementText( "Oacute", "\u00d3" );
1635 parser.defineEntityReplacementText( "Ocirc", "\u00d4" );
1636 parser.defineEntityReplacementText( "Otilde", "\u00d5" );
1637 parser.defineEntityReplacementText( "Ouml", "\u00d6" );
1638 parser.defineEntityReplacementText( "times", "\u00d7" );
1639 parser.defineEntityReplacementText( "Oslash", "\u00d8" );
1640 parser.defineEntityReplacementText( "Ugrave", "\u00d9" );
1641 parser.defineEntityReplacementText( "Uacute", "\u00da" );
1642 parser.defineEntityReplacementText( "Ucirc", "\u00db" );
1643 parser.defineEntityReplacementText( "Uuml", "\u00dc" );
1644 parser.defineEntityReplacementText( "Yacute", "\u00dd" );
1645 parser.defineEntityReplacementText( "THORN", "\u00de" );
1646 parser.defineEntityReplacementText( "szlig", "\u00df" );
1647 parser.defineEntityReplacementText( "agrave", "\u00e0" );
1648 parser.defineEntityReplacementText( "aacute", "\u00e1" );
1649 parser.defineEntityReplacementText( "acirc", "\u00e2" );
1650 parser.defineEntityReplacementText( "atilde", "\u00e3" );
1651 parser.defineEntityReplacementText( "auml", "\u00e4" );
1652 parser.defineEntityReplacementText( "aring", "\u00e5" );
1653 parser.defineEntityReplacementText( "aelig", "\u00e6" );
1654 parser.defineEntityReplacementText( "ccedil", "\u00e7" );
1655 parser.defineEntityReplacementText( "egrave", "\u00e8" );
1656 parser.defineEntityReplacementText( "eacute", "\u00e9" );
1657 parser.defineEntityReplacementText( "ecirc", "\u00ea" );
1658 parser.defineEntityReplacementText( "euml", "\u00eb" );
1659 parser.defineEntityReplacementText( "igrave", "\u00ec" );
1660 parser.defineEntityReplacementText( "iacute", "\u00ed" );
1661 parser.defineEntityReplacementText( "icirc", "\u00ee" );
1662 parser.defineEntityReplacementText( "iuml", "\u00ef" );
1663 parser.defineEntityReplacementText( "eth", "\u00f0" );
1664 parser.defineEntityReplacementText( "ntilde", "\u00f1" );
1665 parser.defineEntityReplacementText( "ograve", "\u00f2" );
1666 parser.defineEntityReplacementText( "oacute", "\u00f3" );
1667 parser.defineEntityReplacementText( "ocirc", "\u00f4" );
1668 parser.defineEntityReplacementText( "otilde", "\u00f5" );
1669 parser.defineEntityReplacementText( "ouml", "\u00f6" );
1670 parser.defineEntityReplacementText( "divide", "\u00f7" );
1671 parser.defineEntityReplacementText( "oslash", "\u00f8" );
1672 parser.defineEntityReplacementText( "ugrave", "\u00f9" );
1673 parser.defineEntityReplacementText( "uacute", "\u00fa" );
1674 parser.defineEntityReplacementText( "ucirc", "\u00fb" );
1675 parser.defineEntityReplacementText( "uuml", "\u00fc" );
1676 parser.defineEntityReplacementText( "yacute", "\u00fd" );
1677 parser.defineEntityReplacementText( "thorn", "\u00fe" );
1678 parser.defineEntityReplacementText( "yuml", "\u00ff" );
1679
1680
1681
1682
1683
1684 parser.defineEntityReplacementText( "OElig", "\u0152" );
1685 parser.defineEntityReplacementText( "oelig", "\u0153" );
1686 parser.defineEntityReplacementText( "Scaron", "\u0160" );
1687 parser.defineEntityReplacementText( "scaron", "\u0161" );
1688 parser.defineEntityReplacementText( "Yuml", "\u0178" );
1689 parser.defineEntityReplacementText( "circ", "\u02c6" );
1690 parser.defineEntityReplacementText( "tilde", "\u02dc" );
1691 parser.defineEntityReplacementText( "ensp", "\u2002" );
1692 parser.defineEntityReplacementText( "emsp", "\u2003" );
1693 parser.defineEntityReplacementText( "thinsp", "\u2009" );
1694 parser.defineEntityReplacementText( "zwnj", "\u200c" );
1695 parser.defineEntityReplacementText( "zwj", "\u200d" );
1696 parser.defineEntityReplacementText( "lrm", "\u200e" );
1697 parser.defineEntityReplacementText( "rlm", "\u200f" );
1698 parser.defineEntityReplacementText( "ndash", "\u2013" );
1699 parser.defineEntityReplacementText( "mdash", "\u2014" );
1700 parser.defineEntityReplacementText( "lsquo", "\u2018" );
1701 parser.defineEntityReplacementText( "rsquo", "\u2019" );
1702 parser.defineEntityReplacementText( "sbquo", "\u201a" );
1703 parser.defineEntityReplacementText( "ldquo", "\u201c" );
1704 parser.defineEntityReplacementText( "rdquo", "\u201d" );
1705 parser.defineEntityReplacementText( "bdquo", "\u201e" );
1706 parser.defineEntityReplacementText( "dagger", "\u2020" );
1707 parser.defineEntityReplacementText( "Dagger", "\u2021" );
1708 parser.defineEntityReplacementText( "permil", "\u2030" );
1709 parser.defineEntityReplacementText( "lsaquo", "\u2039" );
1710 parser.defineEntityReplacementText( "rsaquo", "\u203a" );
1711 parser.defineEntityReplacementText( "euro", "\u20ac" );
1712
1713
1714
1715
1716
1717 parser.defineEntityReplacementText( "fnof", "\u0192" );
1718 parser.defineEntityReplacementText( "Alpha", "\u0391" );
1719 parser.defineEntityReplacementText( "Beta", "\u0392" );
1720 parser.defineEntityReplacementText( "Gamma", "\u0393" );
1721 parser.defineEntityReplacementText( "Delta", "\u0394" );
1722 parser.defineEntityReplacementText( "Epsilon", "\u0395" );
1723 parser.defineEntityReplacementText( "Zeta", "\u0396" );
1724 parser.defineEntityReplacementText( "Eta", "\u0397" );
1725 parser.defineEntityReplacementText( "Theta", "\u0398" );
1726 parser.defineEntityReplacementText( "Iota", "\u0399" );
1727 parser.defineEntityReplacementText( "Kappa", "\u039a" );
1728 parser.defineEntityReplacementText( "Lambda", "\u039b" );
1729 parser.defineEntityReplacementText( "Mu", "\u039c" );
1730 parser.defineEntityReplacementText( "Nu", "\u039d" );
1731 parser.defineEntityReplacementText( "Xi", "\u039e" );
1732 parser.defineEntityReplacementText( "Omicron", "\u039f" );
1733 parser.defineEntityReplacementText( "Pi", "\u03a0" );
1734 parser.defineEntityReplacementText( "Rho", "\u03a1" );
1735 parser.defineEntityReplacementText( "Sigma", "\u03a3" );
1736 parser.defineEntityReplacementText( "Tau", "\u03a4" );
1737 parser.defineEntityReplacementText( "Upsilon", "\u03a5" );
1738 parser.defineEntityReplacementText( "Phi", "\u03a6" );
1739 parser.defineEntityReplacementText( "Chi", "\u03a7" );
1740 parser.defineEntityReplacementText( "Psi", "\u03a8" );
1741 parser.defineEntityReplacementText( "Omega", "\u03a9" );
1742 parser.defineEntityReplacementText( "alpha", "\u03b1" );
1743 parser.defineEntityReplacementText( "beta", "\u03b2" );
1744 parser.defineEntityReplacementText( "gamma", "\u03b3" );
1745 parser.defineEntityReplacementText( "delta", "\u03b4" );
1746 parser.defineEntityReplacementText( "epsilon", "\u03b5" );
1747 parser.defineEntityReplacementText( "zeta", "\u03b6" );
1748 parser.defineEntityReplacementText( "eta", "\u03b7" );
1749 parser.defineEntityReplacementText( "theta", "\u03b8" );
1750 parser.defineEntityReplacementText( "iota", "\u03b9" );
1751 parser.defineEntityReplacementText( "kappa", "\u03ba" );
1752 parser.defineEntityReplacementText( "lambda", "\u03bb" );
1753 parser.defineEntityReplacementText( "mu", "\u03bc" );
1754 parser.defineEntityReplacementText( "nu", "\u03bd" );
1755 parser.defineEntityReplacementText( "xi", "\u03be" );
1756 parser.defineEntityReplacementText( "omicron", "\u03bf" );
1757 parser.defineEntityReplacementText( "pi", "\u03c0" );
1758 parser.defineEntityReplacementText( "rho", "\u03c1" );
1759 parser.defineEntityReplacementText( "sigmaf", "\u03c2" );
1760 parser.defineEntityReplacementText( "sigma", "\u03c3" );
1761 parser.defineEntityReplacementText( "tau", "\u03c4" );
1762 parser.defineEntityReplacementText( "upsilon", "\u03c5" );
1763 parser.defineEntityReplacementText( "phi", "\u03c6" );
1764 parser.defineEntityReplacementText( "chi", "\u03c7" );
1765 parser.defineEntityReplacementText( "psi", "\u03c8" );
1766 parser.defineEntityReplacementText( "omega", "\u03c9" );
1767 parser.defineEntityReplacementText( "thetasym", "\u03d1" );
1768 parser.defineEntityReplacementText( "upsih", "\u03d2" );
1769 parser.defineEntityReplacementText( "piv", "\u03d6" );
1770 parser.defineEntityReplacementText( "bull", "\u2022" );
1771 parser.defineEntityReplacementText( "hellip", "\u2026" );
1772 parser.defineEntityReplacementText( "prime", "\u2032" );
1773 parser.defineEntityReplacementText( "Prime", "\u2033" );
1774 parser.defineEntityReplacementText( "oline", "\u203e" );
1775 parser.defineEntityReplacementText( "frasl", "\u2044" );
1776 parser.defineEntityReplacementText( "weierp", "\u2118" );
1777 parser.defineEntityReplacementText( "image", "\u2111" );
1778 parser.defineEntityReplacementText( "real", "\u211c" );
1779 parser.defineEntityReplacementText( "trade", "\u2122" );
1780 parser.defineEntityReplacementText( "alefsym", "\u2135" );
1781 parser.defineEntityReplacementText( "larr", "\u2190" );
1782 parser.defineEntityReplacementText( "uarr", "\u2191" );
1783 parser.defineEntityReplacementText( "rarr", "\u2192" );
1784 parser.defineEntityReplacementText( "darr", "\u2193" );
1785 parser.defineEntityReplacementText( "harr", "\u2194" );
1786 parser.defineEntityReplacementText( "crarr", "\u21b5" );
1787 parser.defineEntityReplacementText( "lArr", "\u21d0" );
1788 parser.defineEntityReplacementText( "uArr", "\u21d1" );
1789 parser.defineEntityReplacementText( "rArr", "\u21d2" );
1790 parser.defineEntityReplacementText( "dArr", "\u21d3" );
1791 parser.defineEntityReplacementText( "hArr", "\u21d4" );
1792 parser.defineEntityReplacementText( "forall", "\u2200" );
1793 parser.defineEntityReplacementText( "part", "\u2202" );
1794 parser.defineEntityReplacementText( "exist", "\u2203" );
1795 parser.defineEntityReplacementText( "empty", "\u2205" );
1796 parser.defineEntityReplacementText( "nabla", "\u2207" );
1797 parser.defineEntityReplacementText( "isin", "\u2208" );
1798 parser.defineEntityReplacementText( "notin", "\u2209" );
1799 parser.defineEntityReplacementText( "ni", "\u220b" );
1800 parser.defineEntityReplacementText( "prod", "\u220f" );
1801 parser.defineEntityReplacementText( "sum", "\u2211" );
1802 parser.defineEntityReplacementText( "minus", "\u2212" );
1803 parser.defineEntityReplacementText( "lowast", "\u2217" );
1804 parser.defineEntityReplacementText( "radic", "\u221a" );
1805 parser.defineEntityReplacementText( "prop", "\u221d" );
1806 parser.defineEntityReplacementText( "infin", "\u221e" );
1807 parser.defineEntityReplacementText( "ang", "\u2220" );
1808 parser.defineEntityReplacementText( "and", "\u2227" );
1809 parser.defineEntityReplacementText( "or", "\u2228" );
1810 parser.defineEntityReplacementText( "cap", "\u2229" );
1811 parser.defineEntityReplacementText( "cup", "\u222a" );
1812 parser.defineEntityReplacementText( "int", "\u222b" );
1813 parser.defineEntityReplacementText( "there4", "\u2234" );
1814 parser.defineEntityReplacementText( "sim", "\u223c" );
1815 parser.defineEntityReplacementText( "cong", "\u2245" );
1816 parser.defineEntityReplacementText( "asymp", "\u2248" );
1817 parser.defineEntityReplacementText( "ne", "\u2260" );
1818 parser.defineEntityReplacementText( "equiv", "\u2261" );
1819 parser.defineEntityReplacementText( "le", "\u2264" );
1820 parser.defineEntityReplacementText( "ge", "\u2265" );
1821 parser.defineEntityReplacementText( "sub", "\u2282" );
1822 parser.defineEntityReplacementText( "sup", "\u2283" );
1823 parser.defineEntityReplacementText( "nsub", "\u2284" );
1824 parser.defineEntityReplacementText( "sube", "\u2286" );
1825 parser.defineEntityReplacementText( "supe", "\u2287" );
1826 parser.defineEntityReplacementText( "oplus", "\u2295" );
1827 parser.defineEntityReplacementText( "otimes", "\u2297" );
1828 parser.defineEntityReplacementText( "perp", "\u22a5" );
1829 parser.defineEntityReplacementText( "sdot", "\u22c5" );
1830 parser.defineEntityReplacementText( "lceil", "\u2308" );
1831 parser.defineEntityReplacementText( "rceil", "\u2309" );
1832 parser.defineEntityReplacementText( "lfloor", "\u230a" );
1833 parser.defineEntityReplacementText( "rfloor", "\u230b" );
1834 parser.defineEntityReplacementText( "lang", "\u2329" );
1835 parser.defineEntityReplacementText( "rang", "\u232a" );
1836 parser.defineEntityReplacementText( "loz", "\u25ca" );
1837 parser.defineEntityReplacementText( "spades", "\u2660" );
1838 parser.defineEntityReplacementText( "clubs", "\u2663" );
1839 parser.defineEntityReplacementText( "hearts", "\u2665" );
1840 parser.defineEntityReplacementText( "diams", "\u2666" );
1841
1842 }
1843
1844 parser.next();
1845 return parseSettings( "settings", parser, strict );
1846 }
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856 public Settings read( Reader reader )
1857 throws IOException, XmlPullParserException
1858 {
1859 return read( reader, true );
1860 }
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871 public Settings read( InputStream in, boolean strict )
1872 throws IOException, XmlPullParserException
1873 {
1874 Reader reader = ReaderFactory.newXmlReader( in );
1875
1876 return read( reader, strict );
1877 }
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887 public Settings read( InputStream in )
1888 throws IOException, XmlPullParserException
1889 {
1890 Reader reader = ReaderFactory.newXmlReader( in );
1891
1892 return read( reader );
1893 }
1894
1895
1896
1897
1898
1899
1900 public void setAddDefaultEntities( boolean addDefaultEntities )
1901 {
1902 this.addDefaultEntities = addDefaultEntities;
1903 }
1904
1905
1906 }