View Javadoc

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