View Javadoc

1   /*
2    * $Id$
3    */
4   
5   package org.apache.maven.settings.io.xpp3;
6   
7     //---------------------------------/
8    //- Imported classes and packages -/
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   * Class SettingsXpp3Reader.
38   * 
39   * @version $Revision$ $Date$
40   */
41  public class SettingsXpp3Reader {
42  
43  
44        //--------------------------/
45       //- Class/Member Variables -/
46      //--------------------------/
47  
48      /**
49       * If set the parser will be loaded with all single characters
50       * from the XHTML specification.
51       * The entities used:
52       * <ul>
53       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
54       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
55       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
56       * </ul>
57       */
58      private boolean addDefaultEntities = true;
59  
60  
61        //-----------/
62       //- Methods -/
63      //-----------/
64  
65      /**
66       * Returns the state of the "add default entities" flag.
67       * 
68       * @return boolean
69       */
70      public boolean getAddDefaultEntities()
71      {
72          return addDefaultEntities;
73      } //-- boolean getAddDefaultEntities() 
74  
75      /**
76       * Method getBooleanValue.
77       * 
78       * @param s
79       * @param parser
80       * @param attribute
81       * @throws XmlPullParserException
82       * @return boolean
83       */
84      public boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
85          throws XmlPullParserException
86      {
87          return getBooleanValue( s, attribute, parser, null );
88      } //-- boolean getBooleanValue( String, String, XmlPullParser ) 
89  
90      /**
91       * Method getBooleanValue.
92       * 
93       * @param s
94       * @param defaultValue
95       * @param parser
96       * @param attribute
97       * @throws XmlPullParserException
98       * @return boolean
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     } //-- boolean getBooleanValue( String, String, XmlPullParser, String ) 
113 
114     /**
115      * Method getByteValue.
116      * 
117      * @param s
118      * @param strict
119      * @param parser
120      * @param attribute
121      * @throws XmlPullParserException
122      * @return byte
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     } //-- byte getByteValue( String, String, XmlPullParser, boolean ) 
143 
144     /**
145      * Method getCharacterValue.
146      * 
147      * @param s
148      * @param parser
149      * @param attribute
150      * @throws XmlPullParserException
151      * @return char
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     } //-- char getCharacterValue( String, String, XmlPullParser ) 
162 
163     /**
164      * Method getDateValue.
165      * 
166      * @param s
167      * @param parser
168      * @param attribute
169      * @throws XmlPullParserException
170      * @return java.util.Date
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     } //-- java.util.Date getDateValue( String, String, XmlPullParser ) 
177 
178     /**
179      * Method getDateValue.
180      * 
181      * @param s
182      * @param parser
183      * @param dateFormat
184      * @param attribute
185      * @throws XmlPullParserException
186      * @return java.util.Date
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     } //-- java.util.Date getDateValue( String, String, String, XmlPullParser ) 
212 
213     /**
214      * Method getDoubleValue.
215      * 
216      * @param s
217      * @param strict
218      * @param parser
219      * @param attribute
220      * @throws XmlPullParserException
221      * @return double
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     } //-- double getDoubleValue( String, String, XmlPullParser, boolean ) 
242 
243     /**
244      * Method getFloatValue.
245      * 
246      * @param s
247      * @param strict
248      * @param parser
249      * @param attribute
250      * @throws XmlPullParserException
251      * @return float
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     } //-- float getFloatValue( String, String, XmlPullParser, boolean ) 
272 
273     /**
274      * Method getIntegerValue.
275      * 
276      * @param s
277      * @param strict
278      * @param parser
279      * @param attribute
280      * @throws XmlPullParserException
281      * @return int
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     } //-- int getIntegerValue( String, String, XmlPullParser, boolean ) 
302 
303     /**
304      * Method getLongValue.
305      * 
306      * @param s
307      * @param strict
308      * @param parser
309      * @param attribute
310      * @throws XmlPullParserException
311      * @return long
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     } //-- long getLongValue( String, String, XmlPullParser, boolean ) 
332 
333     /**
334      * Method getRequiredAttributeValue.
335      * 
336      * @param s
337      * @param strict
338      * @param parser
339      * @param attribute
340      * @throws XmlPullParserException
341      * @return String
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     } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean ) 
355 
356     /**
357      * Method getShortValue.
358      * 
359      * @param s
360      * @param strict
361      * @param parser
362      * @param attribute
363      * @throws XmlPullParserException
364      * @return short
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     } //-- short getShortValue( String, String, XmlPullParser, boolean ) 
385 
386     /**
387      * Method getTrimmedValue.
388      * 
389      * @param s
390      * @return String
391      */
392     public String getTrimmedValue( String s )
393     {
394         if ( s != null )
395         {
396             s = s.trim();
397         }
398         return s;
399     } //-- String getTrimmedValue( String ) 
400 
401     /**
402      * Method parseActivation.
403      * 
404      * @param tagName
405      * @param strict
406      * @param parser
407      * @throws IOException
408      * @throws XmlPullParserException
409      * @return Activation
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                     // swallow up to end tag since this is not valid
472                     while ( parser.next() != XmlPullParser.END_TAG ) {}
473                 }
474             }
475         }
476         return activation;
477     } //-- Activation parseActivation( String, XmlPullParser, boolean ) 
478 
479     /**
480      * Method parseActivationFile.
481      * 
482      * @param tagName
483      * @param strict
484      * @param parser
485      * @throws IOException
486      * @throws XmlPullParserException
487      * @return ActivationFile
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                     // swallow up to end tag since this is not valid
523                     while ( parser.next() != XmlPullParser.END_TAG ) {}
524                 }
525             }
526         }
527         return activationFile;
528     } //-- ActivationFile parseActivationFile( String, XmlPullParser, boolean ) 
529 
530     /**
531      * Method parseActivationOS.
532      * 
533      * @param tagName
534      * @param strict
535      * @param parser
536      * @throws IOException
537      * @throws XmlPullParserException
538      * @return ActivationOS
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                     // swallow up to end tag since this is not valid
592                     while ( parser.next() != XmlPullParser.END_TAG ) {}
593                 }
594             }
595         }
596         return activationOS;
597     } //-- ActivationOS parseActivationOS( String, XmlPullParser, boolean ) 
598 
599     /**
600      * Method parseActivationProperty.
601      * 
602      * @param tagName
603      * @param strict
604      * @param parser
605      * @throws IOException
606      * @throws XmlPullParserException
607      * @return ActivationProperty
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                     // swallow up to end tag since this is not valid
643                     while ( parser.next() != XmlPullParser.END_TAG ) {}
644                 }
645             }
646         }
647         return activationProperty;
648     } //-- ActivationProperty parseActivationProperty( String, XmlPullParser, boolean ) 
649 
650     /**
651      * Method parseIdentifiableBase.
652      * 
653      * @param tagName
654      * @param strict
655      * @param parser
656      * @throws IOException
657      * @throws XmlPullParserException
658      * @return IdentifiableBase
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                     // swallow up to end tag since this is not valid
685                     while ( parser.next() != XmlPullParser.END_TAG ) {}
686                 }
687             }
688         }
689         return identifiableBase;
690     } //-- IdentifiableBase parseIdentifiableBase( String, XmlPullParser, boolean ) 
691 
692     /**
693      * Method parseMirror.
694      * 
695      * @param tagName
696      * @param strict
697      * @param parser
698      * @throws IOException
699      * @throws XmlPullParserException
700      * @return Mirror
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                     // swallow up to end tag since this is not valid
754                     while ( parser.next() != XmlPullParser.END_TAG ) {}
755                 }
756             }
757         }
758         return mirror;
759     } //-- Mirror parseMirror( String, XmlPullParser, boolean ) 
760 
761     /**
762      * Method parseProfile.
763      * 
764      * @param tagName
765      * @param strict
766      * @param parser
767      * @throws IOException
768      * @throws XmlPullParserException
769      * @return Profile
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                         // swallow up to end tag since this is not valid
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                         // swallow up to end tag since this is not valid
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                     // swallow up to end tag since this is not valid
871                     while ( parser.next() != XmlPullParser.END_TAG ) {}
872                 }
873             }
874         }
875         return profile;
876     } //-- Profile parseProfile( String, XmlPullParser, boolean ) 
877 
878     /**
879      * Method parseProxy.
880      * 
881      * @param tagName
882      * @param strict
883      * @param parser
884      * @throws IOException
885      * @throws XmlPullParserException
886      * @return Proxy
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                     // swallow up to end tag since this is not valid
976                     while ( parser.next() != XmlPullParser.END_TAG ) {}
977                 }
978             }
979         }
980         return proxy;
981     } //-- Proxy parseProxy( String, XmlPullParser, boolean ) 
982 
983     /**
984      * Method parseRepository.
985      * 
986      * @param tagName
987      * @param strict
988      * @param parser
989      * @throws IOException
990      * @throws XmlPullParserException
991      * @return Repository
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                     // swallow up to end tag since this is not valid
1063                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1064                 }
1065             }
1066         }
1067         return repository;
1068     } //-- Repository parseRepository( String, XmlPullParser, boolean ) 
1069 
1070     /**
1071      * Method parseRepositoryBase.
1072      * 
1073      * @param tagName
1074      * @param strict
1075      * @param parser
1076      * @throws IOException
1077      * @throws XmlPullParserException
1078      * @return RepositoryBase
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                     // swallow up to end tag since this is not valid
1132                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1133                 }
1134             }
1135         }
1136         return repositoryBase;
1137     } //-- RepositoryBase parseRepositoryBase( String, XmlPullParser, boolean ) 
1138 
1139     /**
1140      * Method parseRepositoryPolicy.
1141      * 
1142      * @param tagName
1143      * @param strict
1144      * @param parser
1145      * @throws IOException
1146      * @throws XmlPullParserException
1147      * @return RepositoryPolicy
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                     // swallow up to end tag since this is not valid
1192                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1193                 }
1194             }
1195         }
1196         return repositoryPolicy;
1197     } //-- RepositoryPolicy parseRepositoryPolicy( String, XmlPullParser, boolean ) 
1198 
1199     /**
1200      * Method parseServer.
1201      * 
1202      * @param tagName
1203      * @param strict
1204      * @param parser
1205      * @throws IOException
1206      * @throws XmlPullParserException
1207      * @return Server
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                     // swallow up to end tag since this is not valid
1297                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1298                 }
1299             }
1300         }
1301         return server;
1302     } //-- Server parseServer( String, XmlPullParser, boolean ) 
1303 
1304     /**
1305      * Method parseSettings.
1306      * 
1307      * @param tagName
1308      * @param strict
1309      * @param parser
1310      * @throws IOException
1311      * @throws XmlPullParserException
1312      * @return Settings
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                             // swallow up to end tag since this is not valid
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                             // swallow up to end tag since this is not valid
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                             // swallow up to end tag since this is not valid
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                             // swallow up to end tag since this is not valid
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                             // swallow up to end tag since this is not valid
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                             // swallow up to end tag since this is not valid
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     } //-- Settings parseSettings( String, XmlPullParser, boolean ) 
1530 
1531     /**
1532      * Method parseTrackableBase.
1533      * 
1534      * @param tagName
1535      * @param strict
1536      * @param parser
1537      * @throws IOException
1538      * @throws XmlPullParserException
1539      * @return TrackableBase
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                 // swallow up to end tag since this is not valid
1555                 while ( parser.next() != XmlPullParser.END_TAG ) {}
1556             }
1557         }
1558         return trackableBase;
1559     } //-- TrackableBase parseTrackableBase( String, XmlPullParser, boolean ) 
1560 
1561     /**
1562      * @see ReaderFactory#newXmlReader
1563      * 
1564      * @param reader
1565      * @param strict
1566      * @throws IOException
1567      * @throws XmlPullParserException
1568      * @return Settings
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             // Latin 1 entities
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             // Special entities
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             // Symbol entities
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     } //-- Settings read( Reader, boolean ) 
1847 
1848     /**
1849      * @see ReaderFactory#newXmlReader
1850      * 
1851      * @param reader
1852      * @throws IOException
1853      * @throws XmlPullParserException
1854      * @return Settings
1855      */
1856     public Settings read( Reader reader )
1857         throws IOException, XmlPullParserException
1858     {
1859         return read( reader, true );
1860     } //-- Settings read( Reader ) 
1861 
1862     /**
1863      * Method read.
1864      * 
1865      * @param in
1866      * @param strict
1867      * @throws IOException
1868      * @throws XmlPullParserException
1869      * @return Settings
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     } //-- Settings read( InputStream, boolean ) 
1878 
1879     /**
1880      * Method read.
1881      * 
1882      * @param in
1883      * @throws IOException
1884      * @throws XmlPullParserException
1885      * @return Settings
1886      */
1887     public Settings read( InputStream in )
1888         throws IOException, XmlPullParserException
1889     {
1890         Reader reader = ReaderFactory.newXmlReader( in );
1891     
1892         return read( reader );
1893     } //-- Settings read( InputStream ) 
1894 
1895     /**
1896      * Sets the state of the "add default entities" flag.
1897      * 
1898      * @param addDefaultEntities
1899      */
1900     public void setAddDefaultEntities( boolean addDefaultEntities )
1901     {
1902         this.addDefaultEntities = addDefaultEntities;
1903     } //-- void setAddDefaultEntities( boolean ) 
1904 
1905 
1906 }