View Javadoc

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