MavenXpp3Reader xref

View Javadoc

1   /*
2    * $Id$
3    */
4   
5   package org.apache.maven.model.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.model.Activation;
17  import org.apache.maven.model.ActivationFile;
18  import org.apache.maven.model.ActivationOS;
19  import org.apache.maven.model.ActivationProperty;
20  import org.apache.maven.model.Build;
21  import org.apache.maven.model.BuildBase;
22  import org.apache.maven.model.CiManagement;
23  import org.apache.maven.model.ConfigurationContainer;
24  import org.apache.maven.model.Contributor;
25  import org.apache.maven.model.Dependency;
26  import org.apache.maven.model.DependencyManagement;
27  import org.apache.maven.model.DeploymentRepository;
28  import org.apache.maven.model.Developer;
29  import org.apache.maven.model.DistributionManagement;
30  import org.apache.maven.model.Exclusion;
31  import org.apache.maven.model.Extension;
32  import org.apache.maven.model.FileSet;
33  import org.apache.maven.model.IssueManagement;
34  import org.apache.maven.model.License;
35  import org.apache.maven.model.MailingList;
36  import org.apache.maven.model.Model;
37  import org.apache.maven.model.ModelBase;
38  import org.apache.maven.model.Notifier;
39  import org.apache.maven.model.Organization;
40  import org.apache.maven.model.Parent;
41  import org.apache.maven.model.PatternSet;
42  import org.apache.maven.model.Plugin;
43  import org.apache.maven.model.PluginConfiguration;
44  import org.apache.maven.model.PluginContainer;
45  import org.apache.maven.model.PluginExecution;
46  import org.apache.maven.model.PluginManagement;
47  import org.apache.maven.model.Prerequisites;
48  import org.apache.maven.model.Profile;
49  import org.apache.maven.model.Relocation;
50  import org.apache.maven.model.ReportPlugin;
51  import org.apache.maven.model.ReportSet;
52  import org.apache.maven.model.Reporting;
53  import org.apache.maven.model.Repository;
54  import org.apache.maven.model.RepositoryBase;
55  import org.apache.maven.model.RepositoryPolicy;
56  import org.apache.maven.model.Resource;
57  import org.apache.maven.model.Scm;
58  import org.apache.maven.model.Site;
59  import org.codehaus.plexus.util.ReaderFactory;
60  import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
61  import org.codehaus.plexus.util.xml.pull.MXParser;
62  import org.codehaus.plexus.util.xml.pull.XmlPullParser;
63  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
64  
65  /**
66   * Class MavenXpp3Reader.
67   * 
68   * @version $Revision$ $Date$
69   */
70  public class MavenXpp3Reader {
71  
72  
73        //--------------------------/
74       //- Class/Member Variables -/
75      //--------------------------/
76  
77      /**
78       * If set the parser will be loaded with all single characters
79       * from the XHTML specification.
80       * The entities used:
81       * <ul>
82       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
83       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
84       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
85       * </ul>
86       */
87      private boolean addDefaultEntities = true;
88  
89  
90        //-----------/
91       //- Methods -/
92      //-----------/
93  
94      /**
95       * Returns the state of the "add default entities" flag.
96       * 
97       * @return boolean
98       */
99      public boolean getAddDefaultEntities()
100     {
101         return addDefaultEntities;
102     } //-- boolean getAddDefaultEntities() 
103 
104     /**
105      * Method getBooleanValue.
106      * 
107      * @param s
108      * @param parser
109      * @param attribute
110      * @throws XmlPullParserException
111      * @return boolean
112      */
113     public boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
114         throws XmlPullParserException
115     {
116         return getBooleanValue( s, attribute, parser, null );
117     } //-- boolean getBooleanValue( String, String, XmlPullParser ) 
118 
119     /**
120      * Method getBooleanValue.
121      * 
122      * @param s
123      * @param defaultValue
124      * @param parser
125      * @param attribute
126      * @throws XmlPullParserException
127      * @return boolean
128      */
129     public boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
130         throws XmlPullParserException
131     {
132         if ( s != null && s.length() != 0 )
133         {
134             return Boolean.valueOf( s ).booleanValue();
135         }
136         if ( defaultValue != null )
137         {
138             return Boolean.valueOf( defaultValue ).booleanValue();
139         }
140         return false;
141     } //-- boolean getBooleanValue( String, String, XmlPullParser, String ) 
142 
143     /**
144      * Method getByteValue.
145      * 
146      * @param s
147      * @param strict
148      * @param parser
149      * @param attribute
150      * @throws XmlPullParserException
151      * @return byte
152      */
153     public byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
154         throws XmlPullParserException
155     {
156         if ( s != null )
157         {
158             try
159             {
160                 return Byte.valueOf( s ).byteValue();
161             }
162             catch ( NumberFormatException e )
163             {
164                 if ( strict )
165                 {
166                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, null );
167                 }
168             }
169         }
170         return 0;
171     } //-- byte getByteValue( String, String, XmlPullParser, boolean ) 
172 
173     /**
174      * Method getCharacterValue.
175      * 
176      * @param s
177      * @param parser
178      * @param attribute
179      * @throws XmlPullParserException
180      * @return char
181      */
182     public char getCharacterValue( String s, String attribute, XmlPullParser parser )
183         throws XmlPullParserException
184     {
185         if ( s != null )
186         {
187             return s.charAt( 0 );
188         }
189         return 0;
190     } //-- char getCharacterValue( String, String, XmlPullParser ) 
191 
192     /**
193      * Method getDateValue.
194      * 
195      * @param s
196      * @param parser
197      * @param attribute
198      * @throws XmlPullParserException
199      * @return java.util.Date
200      */
201     public java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
202         throws XmlPullParserException
203     {
204         return getDateValue( s, attribute, null, parser );
205     } //-- java.util.Date getDateValue( String, String, XmlPullParser ) 
206 
207     /**
208      * Method getDateValue.
209      * 
210      * @param s
211      * @param parser
212      * @param dateFormat
213      * @param attribute
214      * @throws XmlPullParserException
215      * @return java.util.Date
216      */
217     public java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
218         throws XmlPullParserException
219     {
220         if ( s != null )
221         {
222             if ( dateFormat == null )
223             {
224                 return new java.util.Date( Long.valueOf( s ).longValue() );
225             }
226             else
227             {
228                 DateFormat dateParser = new java.text.SimpleDateFormat( dateFormat, Locale.US );
229                 try
230                 {
231                     return dateParser.parse( s );
232                 }
233                 catch ( java.text.ParseException e )
234                 {
235                     throw new XmlPullParserException( e.getMessage() );
236                 }
237             }
238         }
239         return null;
240     } //-- java.util.Date getDateValue( String, String, String, XmlPullParser ) 
241 
242     /**
243      * Method getDoubleValue.
244      * 
245      * @param s
246      * @param strict
247      * @param parser
248      * @param attribute
249      * @throws XmlPullParserException
250      * @return double
251      */
252     public double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
253         throws XmlPullParserException
254     {
255         if ( s != null )
256         {
257             try
258             {
259                 return Double.valueOf( s ).doubleValue();
260             }
261             catch ( NumberFormatException e )
262             {
263                 if ( strict )
264                 {
265                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
266                 }
267             }
268         }
269         return 0;
270     } //-- double getDoubleValue( String, String, XmlPullParser, boolean ) 
271 
272     /**
273      * Method getFloatValue.
274      * 
275      * @param s
276      * @param strict
277      * @param parser
278      * @param attribute
279      * @throws XmlPullParserException
280      * @return float
281      */
282     public float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
283         throws XmlPullParserException
284     {
285         if ( s != null )
286         {
287             try
288             {
289                 return Float.valueOf( s ).floatValue();
290             }
291             catch ( NumberFormatException e )
292             {
293                 if ( strict )
294                 {
295                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
296                 }
297             }
298         }
299         return 0;
300     } //-- float getFloatValue( String, String, XmlPullParser, boolean ) 
301 
302     /**
303      * Method getIntegerValue.
304      * 
305      * @param s
306      * @param strict
307      * @param parser
308      * @param attribute
309      * @throws XmlPullParserException
310      * @return int
311      */
312     public int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
313         throws XmlPullParserException
314     {
315         if ( s != null )
316         {
317             try
318             {
319                 return Integer.valueOf( s ).intValue();
320             }
321             catch ( NumberFormatException e )
322             {
323                 if ( strict )
324                 {
325                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, null );
326                 }
327             }
328         }
329         return 0;
330     } //-- int getIntegerValue( String, String, XmlPullParser, boolean ) 
331 
332     /**
333      * Method getLongValue.
334      * 
335      * @param s
336      * @param strict
337      * @param parser
338      * @param attribute
339      * @throws XmlPullParserException
340      * @return long
341      */
342     public long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
343         throws XmlPullParserException
344     {
345         if ( s != null )
346         {
347             try
348             {
349                 return Long.valueOf( s ).longValue();
350             }
351             catch ( NumberFormatException e )
352             {
353                 if ( strict )
354                 {
355                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, null );
356                 }
357             }
358         }
359         return 0;
360     } //-- long getLongValue( String, String, XmlPullParser, boolean ) 
361 
362     /**
363      * Method getRequiredAttributeValue.
364      * 
365      * @param s
366      * @param strict
367      * @param parser
368      * @param attribute
369      * @throws XmlPullParserException
370      * @return String
371      */
372     public String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
373         throws XmlPullParserException
374     {
375         if ( s == null )
376         {
377             if ( strict )
378             {
379                 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
380             }
381         }
382         return s;
383     } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean ) 
384 
385     /**
386      * Method getShortValue.
387      * 
388      * @param s
389      * @param strict
390      * @param parser
391      * @param attribute
392      * @throws XmlPullParserException
393      * @return short
394      */
395     public short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
396         throws XmlPullParserException
397     {
398         if ( s != null )
399         {
400             try
401             {
402                 return Short.valueOf( s ).shortValue();
403             }
404             catch ( NumberFormatException e )
405             {
406                 if ( strict )
407                 {
408                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, null );
409                 }
410             }
411         }
412         return 0;
413     } //-- short getShortValue( String, String, XmlPullParser, boolean ) 
414 
415     /**
416      * Method getTrimmedValue.
417      * 
418      * @param s
419      * @return String
420      */
421     public String getTrimmedValue( String s )
422     {
423         if ( s != null )
424         {
425             s = s.trim();
426         }
427         return s;
428     } //-- String getTrimmedValue( String ) 
429 
430     /**
431      * Method parseActivation.
432      * 
433      * @param tagName
434      * @param strict
435      * @param parser
436      * @throws IOException
437      * @throws XmlPullParserException
438      * @return Activation
439      */
440     private Activation parseActivation( String tagName, XmlPullParser parser, boolean strict )
441         throws IOException, XmlPullParserException
442     {
443         Activation activation = new Activation();
444         java.util.Set parsed = new java.util.HashSet();
445         while ( parser.nextTag() == XmlPullParser.START_TAG )
446         {
447             if ( parser.getName().equals( "activeByDefault" )  )
448             {
449                 if ( parsed.contains( "activeByDefault" ) )
450                 {
451                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
452                 }
453                 parsed.add( "activeByDefault" );
454                 activation.setActiveByDefault( getBooleanValue( getTrimmedValue( parser.nextText()), "activeByDefault", parser, "false" ) );
455             }
456             else if ( parser.getName().equals( "jdk" )  )
457             {
458                 if ( parsed.contains( "jdk" ) )
459                 {
460                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
461                 }
462                 parsed.add( "jdk" );
463                 activation.setJdk( getTrimmedValue( parser.nextText()) );
464             }
465             else if ( parser.getName().equals( "os" )  )
466             {
467                 if ( parsed.contains( "os" ) )
468                 {
469                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
470                 }
471                 parsed.add( "os" );
472                 activation.setOs( parseActivationOS( "os", parser, strict ) );
473             }
474             else if ( parser.getName().equals( "property" )  )
475             {
476                 if ( parsed.contains( "property" ) )
477                 {
478                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
479                 }
480                 parsed.add( "property" );
481                 activation.setProperty( parseActivationProperty( "property", parser, strict ) );
482             }
483             else if ( parser.getName().equals( "file" )  )
484             {
485                 if ( parsed.contains( "file" ) )
486                 {
487                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
488                 }
489                 parsed.add( "file" );
490                 activation.setFile( parseActivationFile( "file", parser, strict ) );
491             }
492             else
493             {
494                 if ( strict )
495                 {
496                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
497                 }
498                 else
499                 {
500                     // swallow up to end tag since this is not valid
501                     while ( parser.next() != XmlPullParser.END_TAG ) {}
502                 }
503             }
504         }
505         return activation;
506     } //-- Activation parseActivation( String, XmlPullParser, boolean ) 
507 
508     /**
509      * Method parseActivationFile.
510      * 
511      * @param tagName
512      * @param strict
513      * @param parser
514      * @throws IOException
515      * @throws XmlPullParserException
516      * @return ActivationFile
517      */
518     private ActivationFile parseActivationFile( String tagName, XmlPullParser parser, boolean strict )
519         throws IOException, XmlPullParserException
520     {
521         ActivationFile activationFile = new ActivationFile();
522         java.util.Set parsed = new java.util.HashSet();
523         while ( parser.nextTag() == XmlPullParser.START_TAG )
524         {
525             if ( parser.getName().equals( "missing" )  )
526             {
527                 if ( parsed.contains( "missing" ) )
528                 {
529                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
530                 }
531                 parsed.add( "missing" );
532                 activationFile.setMissing( getTrimmedValue( parser.nextText()) );
533             }
534             else if ( parser.getName().equals( "exists" )  )
535             {
536                 if ( parsed.contains( "exists" ) )
537                 {
538                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
539                 }
540                 parsed.add( "exists" );
541                 activationFile.setExists( getTrimmedValue( parser.nextText()) );
542             }
543             else
544             {
545                 if ( strict )
546                 {
547                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
548                 }
549                 else
550                 {
551                     // swallow up to end tag since this is not valid
552                     while ( parser.next() != XmlPullParser.END_TAG ) {}
553                 }
554             }
555         }
556         return activationFile;
557     } //-- ActivationFile parseActivationFile( String, XmlPullParser, boolean ) 
558 
559     /**
560      * Method parseActivationOS.
561      * 
562      * @param tagName
563      * @param strict
564      * @param parser
565      * @throws IOException
566      * @throws XmlPullParserException
567      * @return ActivationOS
568      */
569     private ActivationOS parseActivationOS( String tagName, XmlPullParser parser, boolean strict )
570         throws IOException, XmlPullParserException
571     {
572         ActivationOS activationOS = new ActivationOS();
573         java.util.Set parsed = new java.util.HashSet();
574         while ( parser.nextTag() == XmlPullParser.START_TAG )
575         {
576             if ( parser.getName().equals( "name" )  )
577             {
578                 if ( parsed.contains( "name" ) )
579                 {
580                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
581                 }
582                 parsed.add( "name" );
583                 activationOS.setName( getTrimmedValue( parser.nextText()) );
584             }
585             else if ( parser.getName().equals( "family" )  )
586             {
587                 if ( parsed.contains( "family" ) )
588                 {
589                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
590                 }
591                 parsed.add( "family" );
592                 activationOS.setFamily( getTrimmedValue( parser.nextText()) );
593             }
594             else if ( parser.getName().equals( "arch" )  )
595             {
596                 if ( parsed.contains( "arch" ) )
597                 {
598                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
599                 }
600                 parsed.add( "arch" );
601                 activationOS.setArch( getTrimmedValue( parser.nextText()) );
602             }
603             else if ( parser.getName().equals( "version" )  )
604             {
605                 if ( parsed.contains( "version" ) )
606                 {
607                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
608                 }
609                 parsed.add( "version" );
610                 activationOS.setVersion( getTrimmedValue( parser.nextText()) );
611             }
612             else
613             {
614                 if ( strict )
615                 {
616                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
617                 }
618                 else
619                 {
620                     // swallow up to end tag since this is not valid
621                     while ( parser.next() != XmlPullParser.END_TAG ) {}
622                 }
623             }
624         }
625         return activationOS;
626     } //-- ActivationOS parseActivationOS( String, XmlPullParser, boolean ) 
627 
628     /**
629      * Method parseActivationProperty.
630      * 
631      * @param tagName
632      * @param strict
633      * @param parser
634      * @throws IOException
635      * @throws XmlPullParserException
636      * @return ActivationProperty
637      */
638     private ActivationProperty parseActivationProperty( String tagName, XmlPullParser parser, boolean strict )
639         throws IOException, XmlPullParserException
640     {
641         ActivationProperty activationProperty = new ActivationProperty();
642         java.util.Set parsed = new java.util.HashSet();
643         while ( parser.nextTag() == XmlPullParser.START_TAG )
644         {
645             if ( parser.getName().equals( "name" )  )
646             {
647                 if ( parsed.contains( "name" ) )
648                 {
649                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
650                 }
651                 parsed.add( "name" );
652                 activationProperty.setName( getTrimmedValue( parser.nextText()) );
653             }
654             else if ( parser.getName().equals( "value" )  )
655             {
656                 if ( parsed.contains( "value" ) )
657                 {
658                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
659                 }
660                 parsed.add( "value" );
661                 activationProperty.setValue( getTrimmedValue( parser.nextText()) );
662             }
663             else
664             {
665                 if ( strict )
666                 {
667                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
668                 }
669                 else
670                 {
671                     // swallow up to end tag since this is not valid
672                     while ( parser.next() != XmlPullParser.END_TAG ) {}
673                 }
674             }
675         }
676         return activationProperty;
677     } //-- ActivationProperty parseActivationProperty( String, XmlPullParser, boolean ) 
678 
679     /**
680      * Method parseBuild.
681      * 
682      * @param tagName
683      * @param strict
684      * @param parser
685      * @throws IOException
686      * @throws XmlPullParserException
687      * @return Build
688      */
689     private Build parseBuild( String tagName, XmlPullParser parser, boolean strict )
690         throws IOException, XmlPullParserException
691     {
692         Build build = new Build();
693         java.util.Set parsed = new java.util.HashSet();
694         while ( parser.nextTag() == XmlPullParser.START_TAG )
695         {
696             if ( parser.getName().equals( "sourceDirectory" )  )
697             {
698                 if ( parsed.contains( "sourceDirectory" ) )
699                 {
700                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
701                 }
702                 parsed.add( "sourceDirectory" );
703                 build.setSourceDirectory( getTrimmedValue( parser.nextText()) );
704             }
705             else if ( parser.getName().equals( "scriptSourceDirectory" )  )
706             {
707                 if ( parsed.contains( "scriptSourceDirectory" ) )
708                 {
709                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
710                 }
711                 parsed.add( "scriptSourceDirectory" );
712                 build.setScriptSourceDirectory( getTrimmedValue( parser.nextText()) );
713             }
714             else if ( parser.getName().equals( "testSourceDirectory" )  )
715             {
716                 if ( parsed.contains( "testSourceDirectory" ) )
717                 {
718                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
719                 }
720                 parsed.add( "testSourceDirectory" );
721                 build.setTestSourceDirectory( getTrimmedValue( parser.nextText()) );
722             }
723             else if ( parser.getName().equals( "outputDirectory" )  )
724             {
725                 if ( parsed.contains( "outputDirectory" ) )
726                 {
727                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
728                 }
729                 parsed.add( "outputDirectory" );
730                 build.setOutputDirectory( getTrimmedValue( parser.nextText()) );
731             }
732             else if ( parser.getName().equals( "testOutputDirectory" )  )
733             {
734                 if ( parsed.contains( "testOutputDirectory" ) )
735                 {
736                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
737                 }
738                 parsed.add( "testOutputDirectory" );
739                 build.setTestOutputDirectory( getTrimmedValue( parser.nextText()) );
740             }
741             else if ( parser.getName().equals( "extensions" )  )
742             {
743                 if ( parsed.contains( "extensions" ) )
744                 {
745                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
746                 }
747                 parsed.add( "extensions" );
748                 java.util.List extensions = new java.util.ArrayList();
749                 build.setExtensions( extensions );
750                 while ( parser.nextTag() == XmlPullParser.START_TAG )
751                 {
752                     if ( parser.getName().equals( "extension" ) )
753                     {
754                         extensions.add( parseExtension( "extension", parser, strict ) );
755                     }
756                     else if ( strict )
757                     {
758                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
759                     }
760                     else
761                     {
762                         // swallow up to end tag since this is not valid
763                         while ( parser.next() != XmlPullParser.END_TAG ) {}
764                     }
765                 }
766             }
767             else if ( parser.getName().equals( "defaultGoal" )  )
768             {
769                 if ( parsed.contains( "defaultGoal" ) )
770                 {
771                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
772                 }
773                 parsed.add( "defaultGoal" );
774                 build.setDefaultGoal( getTrimmedValue( parser.nextText()) );
775             }
776             else if ( parser.getName().equals( "resources" )  )
777             {
778                 if ( parsed.contains( "resources" ) )
779                 {
780                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
781                 }
782                 parsed.add( "resources" );
783                 java.util.List resources = new java.util.ArrayList();
784                 build.setResources( resources );
785                 while ( parser.nextTag() == XmlPullParser.START_TAG )
786                 {
787                     if ( parser.getName().equals( "resource" ) )
788                     {
789                         resources.add( parseResource( "resource", parser, strict ) );
790                     }
791                     else if ( strict )
792                     {
793                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
794                     }
795                     else
796                     {
797                         // swallow up to end tag since this is not valid
798                         while ( parser.next() != XmlPullParser.END_TAG ) {}
799                     }
800                 }
801             }
802             else if ( parser.getName().equals( "testResources" )  )
803             {
804                 if ( parsed.contains( "testResources" ) )
805                 {
806                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
807                 }
808                 parsed.add( "testResources" );
809                 java.util.List testResources = new java.util.ArrayList();
810                 build.setTestResources( testResources );
811                 while ( parser.nextTag() == XmlPullParser.START_TAG )
812                 {
813                     if ( parser.getName().equals( "testResource" ) )
814                     {
815                         testResources.add( parseResource( "testResource", parser, strict ) );
816                     }
817                     else if ( strict )
818                     {
819                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
820                     }
821                     else
822                     {
823                         // swallow up to end tag since this is not valid
824                         while ( parser.next() != XmlPullParser.END_TAG ) {}
825                     }
826                 }
827             }
828             else if ( parser.getName().equals( "directory" )  )
829             {
830                 if ( parsed.contains( "directory" ) )
831                 {
832                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
833                 }
834                 parsed.add( "directory" );
835                 build.setDirectory( getTrimmedValue( parser.nextText()) );
836             }
837             else if ( parser.getName().equals( "finalName" )  )
838             {
839                 if ( parsed.contains( "finalName" ) )
840                 {
841                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
842                 }
843                 parsed.add( "finalName" );
844                 build.setFinalName( getTrimmedValue( parser.nextText()) );
845             }
846             else if ( parser.getName().equals( "filters" )  )
847             {
848                 if ( parsed.contains( "filters" ) )
849                 {
850                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
851                 }
852                 parsed.add( "filters" );
853                 java.util.List filters = new java.util.ArrayList();
854                 build.setFilters( filters );
855                 while ( parser.nextTag() == XmlPullParser.START_TAG )
856                 {
857                     if ( parser.getName().equals( "filter" ) )
858                     {
859                         filters.add( getTrimmedValue( parser.nextText()) );
860                     }
861                     else if ( strict )
862                     {
863                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
864                     }
865                     else
866                     {
867                         // swallow up to end tag since this is not valid
868                         while ( parser.next() != XmlPullParser.END_TAG ) {}
869                     }
870                 }
871             }
872             else if ( parser.getName().equals( "pluginManagement" )  )
873             {
874                 if ( parsed.contains( "pluginManagement" ) )
875                 {
876                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
877                 }
878                 parsed.add( "pluginManagement" );
879                 build.setPluginManagement( parsePluginManagement( "pluginManagement", parser, strict ) );
880             }
881             else if ( parser.getName().equals( "plugins" )  )
882             {
883                 if ( parsed.contains( "plugins" ) )
884                 {
885                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
886                 }
887                 parsed.add( "plugins" );
888                 java.util.List plugins = new java.util.ArrayList();
889                 build.setPlugins( plugins );
890                 while ( parser.nextTag() == XmlPullParser.START_TAG )
891                 {
892                     if ( parser.getName().equals( "plugin" ) )
893                     {
894                         plugins.add( parsePlugin( "plugin", parser, strict ) );
895                     }
896                     else if ( strict )
897                     {
898                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
899                     }
900                     else
901                     {
902                         // swallow up to end tag since this is not valid
903                         while ( parser.next() != XmlPullParser.END_TAG ) {}
904                     }
905                 }
906             }
907             else
908             {
909                 if ( strict )
910                 {
911                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
912                 }
913                 else
914                 {
915                     // swallow up to end tag since this is not valid
916                     while ( parser.next() != XmlPullParser.END_TAG ) {}
917                 }
918             }
919         }
920         return build;
921     } //-- Build parseBuild( String, XmlPullParser, boolean ) 
922 
923     /**
924      * Method parseBuildBase.
925      * 
926      * @param tagName
927      * @param strict
928      * @param parser
929      * @throws IOException
930      * @throws XmlPullParserException
931      * @return BuildBase
932      */
933     private BuildBase parseBuildBase( String tagName, XmlPullParser parser, boolean strict )
934         throws IOException, XmlPullParserException
935     {
936         BuildBase buildBase = new BuildBase();
937         java.util.Set parsed = new java.util.HashSet();
938         while ( parser.nextTag() == XmlPullParser.START_TAG )
939         {
940             if ( parser.getName().equals( "defaultGoal" )  )
941             {
942                 if ( parsed.contains( "defaultGoal" ) )
943                 {
944                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
945                 }
946                 parsed.add( "defaultGoal" );
947                 buildBase.setDefaultGoal( getTrimmedValue( parser.nextText()) );
948             }
949             else if ( parser.getName().equals( "resources" )  )
950             {
951                 if ( parsed.contains( "resources" ) )
952                 {
953                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
954                 }
955                 parsed.add( "resources" );
956                 java.util.List resources = new java.util.ArrayList();
957                 buildBase.setResources( resources );
958                 while ( parser.nextTag() == XmlPullParser.START_TAG )
959                 {
960                     if ( parser.getName().equals( "resource" ) )
961                     {
962                         resources.add( parseResource( "resource", parser, strict ) );
963                     }
964                     else if ( strict )
965                     {
966                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
967                     }
968                     else
969                     {
970                         // swallow up to end tag since this is not valid
971                         while ( parser.next() != XmlPullParser.END_TAG ) {}
972                     }
973                 }
974             }
975             else if ( parser.getName().equals( "testResources" )  )
976             {
977                 if ( parsed.contains( "testResources" ) )
978                 {
979                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
980                 }
981                 parsed.add( "testResources" );
982                 java.util.List testResources = new java.util.ArrayList();
983                 buildBase.setTestResources( testResources );
984                 while ( parser.nextTag() == XmlPullParser.START_TAG )
985                 {
986                     if ( parser.getName().equals( "testResource" ) )
987                     {
988                         testResources.add( parseResource( "testResource", parser, strict ) );
989                     }
990                     else if ( strict )
991                     {
992                         throw new XmlPullParserException( "Unrecognised association: '" + 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             else if ( parser.getName().equals( "directory" )  )
1002             {
1003                 if ( parsed.contains( "directory" ) )
1004                 {
1005                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1006                 }
1007                 parsed.add( "directory" );
1008                 buildBase.setDirectory( getTrimmedValue( parser.nextText()) );
1009             }
1010             else if ( parser.getName().equals( "finalName" )  )
1011             {
1012                 if ( parsed.contains( "finalName" ) )
1013                 {
1014                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1015                 }
1016                 parsed.add( "finalName" );
1017                 buildBase.setFinalName( getTrimmedValue( parser.nextText()) );
1018             }
1019             else if ( parser.getName().equals( "filters" )  )
1020             {
1021                 if ( parsed.contains( "filters" ) )
1022                 {
1023                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1024                 }
1025                 parsed.add( "filters" );
1026                 java.util.List filters = new java.util.ArrayList();
1027                 buildBase.setFilters( filters );
1028                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1029                 {
1030                     if ( parser.getName().equals( "filter" ) )
1031                     {
1032                         filters.add( getTrimmedValue( parser.nextText()) );
1033                     }
1034                     else if ( strict )
1035                     {
1036                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1037                     }
1038                     else
1039                     {
1040                         // swallow up to end tag since this is not valid
1041                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1042                     }
1043                 }
1044             }
1045             else if ( parser.getName().equals( "pluginManagement" )  )
1046             {
1047                 if ( parsed.contains( "pluginManagement" ) )
1048                 {
1049                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1050                 }
1051                 parsed.add( "pluginManagement" );
1052                 buildBase.setPluginManagement( parsePluginManagement( "pluginManagement", parser, strict ) );
1053             }
1054             else if ( parser.getName().equals( "plugins" )  )
1055             {
1056                 if ( parsed.contains( "plugins" ) )
1057                 {
1058                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1059                 }
1060                 parsed.add( "plugins" );
1061                 java.util.List plugins = new java.util.ArrayList();
1062                 buildBase.setPlugins( plugins );
1063                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1064                 {
1065                     if ( parser.getName().equals( "plugin" ) )
1066                     {
1067                         plugins.add( parsePlugin( "plugin", parser, strict ) );
1068                     }
1069                     else if ( strict )
1070                     {
1071                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1072                     }
1073                     else
1074                     {
1075                         // swallow up to end tag since this is not valid
1076                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1077                     }
1078                 }
1079             }
1080             else
1081             {
1082                 if ( strict )
1083                 {
1084                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1085                 }
1086                 else
1087                 {
1088                     // swallow up to end tag since this is not valid
1089                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1090                 }
1091             }
1092         }
1093         return buildBase;
1094     } //-- BuildBase parseBuildBase( String, XmlPullParser, boolean ) 
1095 
1096     /**
1097      * Method parseCiManagement.
1098      * 
1099      * @param tagName
1100      * @param strict
1101      * @param parser
1102      * @throws IOException
1103      * @throws XmlPullParserException
1104      * @return CiManagement
1105      */
1106     private CiManagement parseCiManagement( String tagName, XmlPullParser parser, boolean strict )
1107         throws IOException, XmlPullParserException
1108     {
1109         CiManagement ciManagement = new CiManagement();
1110         java.util.Set parsed = new java.util.HashSet();
1111         while ( parser.nextTag() == XmlPullParser.START_TAG )
1112         {
1113             if ( parser.getName().equals( "system" )  )
1114             {
1115                 if ( parsed.contains( "system" ) )
1116                 {
1117                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1118                 }
1119                 parsed.add( "system" );
1120                 ciManagement.setSystem( getTrimmedValue( parser.nextText()) );
1121             }
1122             else if ( parser.getName().equals( "url" )  )
1123             {
1124                 if ( parsed.contains( "url" ) )
1125                 {
1126                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1127                 }
1128                 parsed.add( "url" );
1129                 ciManagement.setUrl( getTrimmedValue( parser.nextText()) );
1130             }
1131             else if ( parser.getName().equals( "notifiers" )  )
1132             {
1133                 if ( parsed.contains( "notifiers" ) )
1134                 {
1135                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1136                 }
1137                 parsed.add( "notifiers" );
1138                 java.util.List notifiers = new java.util.ArrayList();
1139                 ciManagement.setNotifiers( notifiers );
1140                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1141                 {
1142                     if ( parser.getName().equals( "notifier" ) )
1143                     {
1144                         notifiers.add( parseNotifier( "notifier", parser, strict ) );
1145                     }
1146                     else if ( strict )
1147                     {
1148                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1149                     }
1150                     else
1151                     {
1152                         // swallow up to end tag since this is not valid
1153                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1154                     }
1155                 }
1156             }
1157             else
1158             {
1159                 if ( strict )
1160                 {
1161                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1162                 }
1163                 else
1164                 {
1165                     // swallow up to end tag since this is not valid
1166                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1167                 }
1168             }
1169         }
1170         return ciManagement;
1171     } //-- CiManagement parseCiManagement( String, XmlPullParser, boolean ) 
1172 
1173     /**
1174      * Method parseConfigurationContainer.
1175      * 
1176      * @param tagName
1177      * @param strict
1178      * @param parser
1179      * @throws IOException
1180      * @throws XmlPullParserException
1181      * @return ConfigurationContainer
1182      */
1183     private ConfigurationContainer parseConfigurationContainer( String tagName, XmlPullParser parser, boolean strict )
1184         throws IOException, XmlPullParserException
1185     {
1186         ConfigurationContainer configurationContainer = new ConfigurationContainer();
1187         java.util.Set parsed = new java.util.HashSet();
1188         while ( parser.nextTag() == XmlPullParser.START_TAG )
1189         {
1190             if ( parser.getName().equals( "inherited" )  )
1191             {
1192                 if ( parsed.contains( "inherited" ) )
1193                 {
1194                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1195                 }
1196                 parsed.add( "inherited" );
1197                 configurationContainer.setInherited( getTrimmedValue( parser.nextText()) );
1198             }
1199             else if ( parser.getName().equals( "configuration" )  )
1200             {
1201                 if ( parsed.contains( "configuration" ) )
1202                 {
1203                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1204                 }
1205                 parsed.add( "configuration" );
1206                 configurationContainer.setConfiguration( Xpp3DomBuilder.build( parser ) );
1207             }
1208             else
1209             {
1210                 if ( strict )
1211                 {
1212                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1213                 }
1214                 else
1215                 {
1216                     // swallow up to end tag since this is not valid
1217                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1218                 }
1219             }
1220         }
1221         return configurationContainer;
1222     } //-- ConfigurationContainer parseConfigurationContainer( String, XmlPullParser, boolean ) 
1223 
1224     /**
1225      * Method parseContributor.
1226      * 
1227      * @param tagName
1228      * @param strict
1229      * @param parser
1230      * @throws IOException
1231      * @throws XmlPullParserException
1232      * @return Contributor
1233      */
1234     private Contributor parseContributor( String tagName, XmlPullParser parser, boolean strict )
1235         throws IOException, XmlPullParserException
1236     {
1237         Contributor contributor = new Contributor();
1238         java.util.Set parsed = new java.util.HashSet();
1239         while ( parser.nextTag() == XmlPullParser.START_TAG )
1240         {
1241             if ( parser.getName().equals( "name" )  )
1242             {
1243                 if ( parsed.contains( "name" ) )
1244                 {
1245                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1246                 }
1247                 parsed.add( "name" );
1248                 contributor.setName( getTrimmedValue( parser.nextText()) );
1249             }
1250             else if ( parser.getName().equals( "email" )  )
1251             {
1252                 if ( parsed.contains( "email" ) )
1253                 {
1254                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1255                 }
1256                 parsed.add( "email" );
1257                 contributor.setEmail( getTrimmedValue( parser.nextText()) );
1258             }
1259             else if ( parser.getName().equals( "url" )  )
1260             {
1261                 if ( parsed.contains( "url" ) )
1262                 {
1263                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1264                 }
1265                 parsed.add( "url" );
1266                 contributor.setUrl( getTrimmedValue( parser.nextText()) );
1267             }
1268             else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" )  )
1269             {
1270                 if ( parsed.contains( "organization" ) )
1271                 {
1272                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1273                 }
1274                 parsed.add( "organization" );
1275                 contributor.setOrganization( getTrimmedValue( parser.nextText()) );
1276             }
1277             else if ( parser.getName().equals( "organizationUrl" ) || parser.getName().equals( "organisationUrl" )  )
1278             {
1279                 if ( parsed.contains( "organizationUrl" ) )
1280                 {
1281                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1282                 }
1283                 parsed.add( "organizationUrl" );
1284                 contributor.setOrganizationUrl( getTrimmedValue( parser.nextText()) );
1285             }
1286             else if ( parser.getName().equals( "roles" )  )
1287             {
1288                 if ( parsed.contains( "roles" ) )
1289                 {
1290                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1291                 }
1292                 parsed.add( "roles" );
1293                 java.util.List roles = new java.util.ArrayList();
1294                 contributor.setRoles( roles );
1295                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1296                 {
1297                     if ( parser.getName().equals( "role" ) )
1298                     {
1299                         roles.add( getTrimmedValue( parser.nextText()) );
1300                     }
1301                     else if ( strict )
1302                     {
1303                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1304                     }
1305                     else
1306                     {
1307                         // swallow up to end tag since this is not valid
1308                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1309                     }
1310                 }
1311             }
1312             else if ( parser.getName().equals( "timezone" )  )
1313             {
1314                 if ( parsed.contains( "timezone" ) )
1315                 {
1316                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1317                 }
1318                 parsed.add( "timezone" );
1319                 contributor.setTimezone( getTrimmedValue( parser.nextText()) );
1320             }
1321             else if ( parser.getName().equals( "properties" )  )
1322             {
1323                 if ( parsed.contains( "properties" ) )
1324                 {
1325                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1326                 }
1327                 parsed.add( "properties" );
1328                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1329                 {
1330                     String key = parser.getName();
1331                     String value = parser.nextText().trim();
1332                     contributor.addProperty( key, value );
1333                 }
1334             }
1335             else
1336             {
1337                 if ( strict )
1338                 {
1339                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1340                 }
1341                 else
1342                 {
1343                     // swallow up to end tag since this is not valid
1344                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1345                 }
1346             }
1347         }
1348         return contributor;
1349     } //-- Contributor parseContributor( String, XmlPullParser, boolean ) 
1350 
1351     /**
1352      * Method parseDependency.
1353      * 
1354      * @param tagName
1355      * @param strict
1356      * @param parser
1357      * @throws IOException
1358      * @throws XmlPullParserException
1359      * @return Dependency
1360      */
1361     private Dependency parseDependency( String tagName, XmlPullParser parser, boolean strict )
1362         throws IOException, XmlPullParserException
1363     {
1364         Dependency dependency = new Dependency();
1365         java.util.Set parsed = new java.util.HashSet();
1366         while ( parser.nextTag() == XmlPullParser.START_TAG )
1367         {
1368             if ( parser.getName().equals( "groupId" )  )
1369             {
1370                 if ( parsed.contains( "groupId" ) )
1371                 {
1372                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1373                 }
1374                 parsed.add( "groupId" );
1375                 dependency.setGroupId( getTrimmedValue( parser.nextText()) );
1376             }
1377             else if ( parser.getName().equals( "artifactId" )  )
1378             {
1379                 if ( parsed.contains( "artifactId" ) )
1380                 {
1381                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1382                 }
1383                 parsed.add( "artifactId" );
1384                 dependency.setArtifactId( getTrimmedValue( parser.nextText()) );
1385             }
1386             else if ( parser.getName().equals( "version" )  )
1387             {
1388                 if ( parsed.contains( "version" ) )
1389                 {
1390                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1391                 }
1392                 parsed.add( "version" );
1393                 dependency.setVersion( getTrimmedValue( parser.nextText()) );
1394             }
1395             else if ( parser.getName().equals( "type" )  )
1396             {
1397                 if ( parsed.contains( "type" ) )
1398                 {
1399                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1400                 }
1401                 parsed.add( "type" );
1402                 dependency.setType( getTrimmedValue( parser.nextText()) );
1403             }
1404             else if ( parser.getName().equals( "classifier" )  )
1405             {
1406                 if ( parsed.contains( "classifier" ) )
1407                 {
1408                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1409                 }
1410                 parsed.add( "classifier" );
1411                 dependency.setClassifier( getTrimmedValue( parser.nextText()) );
1412             }
1413             else if ( parser.getName().equals( "scope" )  )
1414             {
1415                 if ( parsed.contains( "scope" ) )
1416                 {
1417                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1418                 }
1419                 parsed.add( "scope" );
1420                 dependency.setScope( getTrimmedValue( parser.nextText()) );
1421             }
1422             else if ( parser.getName().equals( "systemPath" )  )
1423             {
1424                 if ( parsed.contains( "systemPath" ) )
1425                 {
1426                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1427                 }
1428                 parsed.add( "systemPath" );
1429                 dependency.setSystemPath( getTrimmedValue( parser.nextText()) );
1430             }
1431             else if ( parser.getName().equals( "exclusions" )  )
1432             {
1433                 if ( parsed.contains( "exclusions" ) )
1434                 {
1435                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1436                 }
1437                 parsed.add( "exclusions" );
1438                 java.util.List exclusions = new java.util.ArrayList();
1439                 dependency.setExclusions( exclusions );
1440                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1441                 {
1442                     if ( parser.getName().equals( "exclusion" ) )
1443                     {
1444                         exclusions.add( parseExclusion( "exclusion", parser, strict ) );
1445                     }
1446                     else if ( strict )
1447                     {
1448                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1449                     }
1450                     else
1451                     {
1452                         // swallow up to end tag since this is not valid
1453                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1454                     }
1455                 }
1456             }
1457             else if ( parser.getName().equals( "optional" )  )
1458             {
1459                 if ( parsed.contains( "optional" ) )
1460                 {
1461                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1462                 }
1463                 parsed.add( "optional" );
1464                 dependency.setOptional( getBooleanValue( getTrimmedValue( parser.nextText()), "optional", parser, "false" ) );
1465             }
1466             else
1467             {
1468                 if ( strict )
1469                 {
1470                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1471                 }
1472                 else
1473                 {
1474                     // swallow up to end tag since this is not valid
1475                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1476                 }
1477             }
1478         }
1479         return dependency;
1480     } //-- Dependency parseDependency( String, XmlPullParser, boolean ) 
1481 
1482     /**
1483      * Method parseDependencyManagement.
1484      * 
1485      * @param tagName
1486      * @param strict
1487      * @param parser
1488      * @throws IOException
1489      * @throws XmlPullParserException
1490      * @return DependencyManagement
1491      */
1492     private DependencyManagement parseDependencyManagement( String tagName, XmlPullParser parser, boolean strict )
1493         throws IOException, XmlPullParserException
1494     {
1495         DependencyManagement dependencyManagement = new DependencyManagement();
1496         java.util.Set parsed = new java.util.HashSet();
1497         while ( parser.nextTag() == XmlPullParser.START_TAG )
1498         {
1499             if ( parser.getName().equals( "dependencies" )  )
1500             {
1501                 if ( parsed.contains( "dependencies" ) )
1502                 {
1503                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1504                 }
1505                 parsed.add( "dependencies" );
1506                 java.util.List dependencies = new java.util.ArrayList();
1507                 dependencyManagement.setDependencies( dependencies );
1508                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1509                 {
1510                     if ( parser.getName().equals( "dependency" ) )
1511                     {
1512                         dependencies.add( parseDependency( "dependency", parser, strict ) );
1513                     }
1514                     else if ( strict )
1515                     {
1516                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1517                     }
1518                     else
1519                     {
1520                         // swallow up to end tag since this is not valid
1521                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1522                     }
1523                 }
1524             }
1525             else
1526             {
1527                 if ( strict )
1528                 {
1529                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1530                 }
1531                 else
1532                 {
1533                     // swallow up to end tag since this is not valid
1534                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1535                 }
1536             }
1537         }
1538         return dependencyManagement;
1539     } //-- DependencyManagement parseDependencyManagement( String, XmlPullParser, boolean ) 
1540 
1541     /**
1542      * Method parseDeploymentRepository.
1543      * 
1544      * @param tagName
1545      * @param strict
1546      * @param parser
1547      * @throws IOException
1548      * @throws XmlPullParserException
1549      * @return DeploymentRepository
1550      */
1551     private DeploymentRepository parseDeploymentRepository( String tagName, XmlPullParser parser, boolean strict )
1552         throws IOException, XmlPullParserException
1553     {
1554         DeploymentRepository deploymentRepository = new DeploymentRepository();
1555         java.util.Set parsed = new java.util.HashSet();
1556         while ( parser.nextTag() == XmlPullParser.START_TAG )
1557         {
1558             if ( parser.getName().equals( "uniqueVersion" )  )
1559             {
1560                 if ( parsed.contains( "uniqueVersion" ) )
1561                 {
1562                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1563                 }
1564                 parsed.add( "uniqueVersion" );
1565                 deploymentRepository.setUniqueVersion( getBooleanValue( getTrimmedValue( parser.nextText()), "uniqueVersion", parser, "true" ) );
1566             }
1567             else if ( parser.getName().equals( "id" )  )
1568             {
1569                 if ( parsed.contains( "id" ) )
1570                 {
1571                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1572                 }
1573                 parsed.add( "id" );
1574                 deploymentRepository.setId( getTrimmedValue( parser.nextText()) );
1575             }
1576             else if ( parser.getName().equals( "name" )  )
1577             {
1578                 if ( parsed.contains( "name" ) )
1579                 {
1580                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1581                 }
1582                 parsed.add( "name" );
1583                 deploymentRepository.setName( getTrimmedValue( parser.nextText()) );
1584             }
1585             else if ( parser.getName().equals( "url" )  )
1586             {
1587                 if ( parsed.contains( "url" ) )
1588                 {
1589                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1590                 }
1591                 parsed.add( "url" );
1592                 deploymentRepository.setUrl( getTrimmedValue( parser.nextText()) );
1593             }
1594             else if ( parser.getName().equals( "layout" )  )
1595             {
1596                 if ( parsed.contains( "layout" ) )
1597                 {
1598                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1599                 }
1600                 parsed.add( "layout" );
1601                 deploymentRepository.setLayout( getTrimmedValue( parser.nextText()) );
1602             }
1603             else
1604             {
1605                 if ( strict )
1606                 {
1607                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1608                 }
1609                 else
1610                 {
1611                     // swallow up to end tag since this is not valid
1612                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1613                 }
1614             }
1615         }
1616         return deploymentRepository;
1617     } //-- DeploymentRepository parseDeploymentRepository( String, XmlPullParser, boolean ) 
1618 
1619     /**
1620      * Method parseDeveloper.
1621      * 
1622      * @param tagName
1623      * @param strict
1624      * @param parser
1625      * @throws IOException
1626      * @throws XmlPullParserException
1627      * @return Developer
1628      */
1629     private Developer parseDeveloper( String tagName, XmlPullParser parser, boolean strict )
1630         throws IOException, XmlPullParserException
1631     {
1632         Developer developer = new Developer();
1633         java.util.Set parsed = new java.util.HashSet();
1634         while ( parser.nextTag() == XmlPullParser.START_TAG )
1635         {
1636             if ( parser.getName().equals( "id" )  )
1637             {
1638                 if ( parsed.contains( "id" ) )
1639                 {
1640                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1641                 }
1642                 parsed.add( "id" );
1643                 developer.setId( getTrimmedValue( parser.nextText()) );
1644             }
1645             else if ( parser.getName().equals( "name" )  )
1646             {
1647                 if ( parsed.contains( "name" ) )
1648                 {
1649                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1650                 }
1651                 parsed.add( "name" );
1652                 developer.setName( getTrimmedValue( parser.nextText()) );
1653             }
1654             else if ( parser.getName().equals( "email" )  )
1655             {
1656                 if ( parsed.contains( "email" ) )
1657                 {
1658                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1659                 }
1660                 parsed.add( "email" );
1661                 developer.setEmail( getTrimmedValue( parser.nextText()) );
1662             }
1663             else if ( parser.getName().equals( "url" )  )
1664             {
1665                 if ( parsed.contains( "url" ) )
1666                 {
1667                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1668                 }
1669                 parsed.add( "url" );
1670                 developer.setUrl( getTrimmedValue( parser.nextText()) );
1671             }
1672             else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" )  )
1673             {
1674                 if ( parsed.contains( "organization" ) )
1675                 {
1676                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1677                 }
1678                 parsed.add( "organization" );
1679                 developer.setOrganization( getTrimmedValue( parser.nextText()) );
1680             }
1681             else if ( parser.getName().equals( "organizationUrl" ) || parser.getName().equals( "organisationUrl" )  )
1682             {
1683                 if ( parsed.contains( "organizationUrl" ) )
1684                 {
1685                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1686                 }
1687                 parsed.add( "organizationUrl" );
1688                 developer.setOrganizationUrl( getTrimmedValue( parser.nextText()) );
1689             }
1690             else if ( parser.getName().equals( "roles" )  )
1691             {
1692                 if ( parsed.contains( "roles" ) )
1693                 {
1694                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1695                 }
1696                 parsed.add( "roles" );
1697                 java.util.List roles = new java.util.ArrayList();
1698                 developer.setRoles( roles );
1699                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1700                 {
1701                     if ( parser.getName().equals( "role" ) )
1702                     {
1703                         roles.add( getTrimmedValue( parser.nextText()) );
1704                     }
1705                     else if ( strict )
1706                     {
1707                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1708                     }
1709                     else
1710                     {
1711                         // swallow up to end tag since this is not valid
1712                         while ( parser.next() != XmlPullParser.END_TAG ) {}
1713                     }
1714                 }
1715             }
1716             else if ( parser.getName().equals( "timezone" )  )
1717             {
1718                 if ( parsed.contains( "timezone" ) )
1719                 {
1720                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1721                 }
1722                 parsed.add( "timezone" );
1723                 developer.setTimezone( getTrimmedValue( parser.nextText()) );
1724             }
1725             else if ( parser.getName().equals( "properties" )  )
1726             {
1727                 if ( parsed.contains( "properties" ) )
1728                 {
1729                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1730                 }
1731                 parsed.add( "properties" );
1732                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1733                 {
1734                     String key = parser.getName();
1735                     String value = parser.nextText().trim();
1736                     developer.addProperty( key, value );
1737                 }
1738             }
1739             else
1740             {
1741                 if ( strict )
1742                 {
1743                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1744                 }
1745                 else
1746                 {
1747                     // swallow up to end tag since this is not valid
1748                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1749                 }
1750             }
1751         }
1752         return developer;
1753     } //-- Developer parseDeveloper( String, XmlPullParser, boolean ) 
1754 
1755     /**
1756      * Method parseDistributionManagement.
1757      * 
1758      * @param tagName
1759      * @param strict
1760      * @param parser
1761      * @throws IOException
1762      * @throws XmlPullParserException
1763      * @return DistributionManagement
1764      */
1765     private DistributionManagement parseDistributionManagement( String tagName, XmlPullParser parser, boolean strict )
1766         throws IOException, XmlPullParserException
1767     {
1768         DistributionManagement distributionManagement = new DistributionManagement();
1769         java.util.Set parsed = new java.util.HashSet();
1770         while ( parser.nextTag() == XmlPullParser.START_TAG )
1771         {
1772             if ( parser.getName().equals( "repository" )  )
1773             {
1774                 if ( parsed.contains( "repository" ) )
1775                 {
1776                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1777                 }
1778                 parsed.add( "repository" );
1779                 distributionManagement.setRepository( parseDeploymentRepository( "repository", parser, strict ) );
1780             }
1781             else if ( parser.getName().equals( "snapshotRepository" )  )
1782             {
1783                 if ( parsed.contains( "snapshotRepository" ) )
1784                 {
1785                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1786                 }
1787                 parsed.add( "snapshotRepository" );
1788                 distributionManagement.setSnapshotRepository( parseDeploymentRepository( "snapshotRepository", parser, strict ) );
1789             }
1790             else if ( parser.getName().equals( "site" )  )
1791             {
1792                 if ( parsed.contains( "site" ) )
1793                 {
1794                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1795                 }
1796                 parsed.add( "site" );
1797                 distributionManagement.setSite( parseSite( "site", parser, strict ) );
1798             }
1799             else if ( parser.getName().equals( "downloadUrl" )  )
1800             {
1801                 if ( parsed.contains( "downloadUrl" ) )
1802                 {
1803                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1804                 }
1805                 parsed.add( "downloadUrl" );
1806                 distributionManagement.setDownloadUrl( getTrimmedValue( parser.nextText()) );
1807             }
1808             else if ( parser.getName().equals( "relocation" )  )
1809             {
1810                 if ( parsed.contains( "relocation" ) )
1811                 {
1812                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1813                 }
1814                 parsed.add( "relocation" );
1815                 distributionManagement.setRelocation( parseRelocation( "relocation", parser, strict ) );
1816             }
1817             else if ( parser.getName().equals( "status" )  )
1818             {
1819                 if ( parsed.contains( "status" ) )
1820                 {
1821                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1822                 }
1823                 parsed.add( "status" );
1824                 distributionManagement.setStatus( getTrimmedValue( parser.nextText()) );
1825             }
1826             else
1827             {
1828                 if ( strict )
1829                 {
1830                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1831                 }
1832                 else
1833                 {
1834                     // swallow up to end tag since this is not valid
1835                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1836                 }
1837             }
1838         }
1839         return distributionManagement;
1840     } //-- DistributionManagement parseDistributionManagement( String, XmlPullParser, boolean ) 
1841 
1842     /**
1843      * Method parseExclusion.
1844      * 
1845      * @param tagName
1846      * @param strict
1847      * @param parser
1848      * @throws IOException
1849      * @throws XmlPullParserException
1850      * @return Exclusion
1851      */
1852     private Exclusion parseExclusion( String tagName, XmlPullParser parser, boolean strict )
1853         throws IOException, XmlPullParserException
1854     {
1855         Exclusion exclusion = new Exclusion();
1856         java.util.Set parsed = new java.util.HashSet();
1857         while ( parser.nextTag() == XmlPullParser.START_TAG )
1858         {
1859             if ( parser.getName().equals( "artifactId" )  )
1860             {
1861                 if ( parsed.contains( "artifactId" ) )
1862                 {
1863                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1864                 }
1865                 parsed.add( "artifactId" );
1866                 exclusion.setArtifactId( getTrimmedValue( parser.nextText()) );
1867             }
1868             else if ( parser.getName().equals( "groupId" )  )
1869             {
1870                 if ( parsed.contains( "groupId" ) )
1871                 {
1872                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1873                 }
1874                 parsed.add( "groupId" );
1875                 exclusion.setGroupId( getTrimmedValue( parser.nextText()) );
1876             }
1877             else
1878             {
1879                 if ( strict )
1880                 {
1881                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1882                 }
1883                 else
1884                 {
1885                     // swallow up to end tag since this is not valid
1886                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1887                 }
1888             }
1889         }
1890         return exclusion;
1891     } //-- Exclusion parseExclusion( String, XmlPullParser, boolean ) 
1892 
1893     /**
1894      * Method parseExtension.
1895      * 
1896      * @param tagName
1897      * @param strict
1898      * @param parser
1899      * @throws IOException
1900      * @throws XmlPullParserException
1901      * @return Extension
1902      */
1903     private Extension parseExtension( String tagName, XmlPullParser parser, boolean strict )
1904         throws IOException, XmlPullParserException
1905     {
1906         Extension extension = new Extension();
1907         java.util.Set parsed = new java.util.HashSet();
1908         while ( parser.nextTag() == XmlPullParser.START_TAG )
1909         {
1910             if ( parser.getName().equals( "groupId" )  )
1911             {
1912                 if ( parsed.contains( "groupId" ) )
1913                 {
1914                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1915                 }
1916                 parsed.add( "groupId" );
1917                 extension.setGroupId( getTrimmedValue( parser.nextText()) );
1918             }
1919             else if ( parser.getName().equals( "artifactId" )  )
1920             {
1921                 if ( parsed.contains( "artifactId" ) )
1922                 {
1923                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1924                 }
1925                 parsed.add( "artifactId" );
1926                 extension.setArtifactId( getTrimmedValue( parser.nextText()) );
1927             }
1928             else if ( parser.getName().equals( "version" )  )
1929             {
1930                 if ( parsed.contains( "version" ) )
1931                 {
1932                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1933                 }
1934                 parsed.add( "version" );
1935                 extension.setVersion( getTrimmedValue( parser.nextText()) );
1936             }
1937             else
1938             {
1939                 if ( strict )
1940                 {
1941                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
1942                 }
1943                 else
1944                 {
1945                     // swallow up to end tag since this is not valid
1946                     while ( parser.next() != XmlPullParser.END_TAG ) {}
1947                 }
1948             }
1949         }
1950         return extension;
1951     } //-- Extension parseExtension( String, XmlPullParser, boolean ) 
1952 
1953     /**
1954      * Method parseFileSet.
1955      * 
1956      * @param tagName
1957      * @param strict
1958      * @param parser
1959      * @throws IOException
1960      * @throws XmlPullParserException
1961      * @return FileSet
1962      */
1963     private FileSet parseFileSet( String tagName, XmlPullParser parser, boolean strict )
1964         throws IOException, XmlPullParserException
1965     {
1966         FileSet fileSet = new FileSet();
1967         java.util.Set parsed = new java.util.HashSet();
1968         while ( parser.nextTag() == XmlPullParser.START_TAG )
1969         {
1970             if ( parser.getName().equals( "directory" )  )
1971             {
1972                 if ( parsed.contains( "directory" ) )
1973                 {
1974                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1975                 }
1976                 parsed.add( "directory" );
1977                 fileSet.setDirectory( getTrimmedValue( parser.nextText()) );
1978             }
1979             else if ( parser.getName().equals( "includes" )  )
1980             {
1981                 if ( parsed.contains( "includes" ) )
1982                 {
1983                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
1984                 }
1985                 parsed.add( "includes" );
1986                 java.util.List includes = new java.util.ArrayList();
1987                 fileSet.setIncludes( includes );
1988                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1989                 {
1990                     if ( parser.getName().equals( "include" ) )
1991                     {
1992                         includes.add( getTrimmedValue( parser.nextText()) );
1993                     }
1994                     else if ( strict )
1995                     {
1996                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
1997                     }
1998                     else
1999                     {
2000                         // swallow up to end tag since this is not valid
2001                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2002                     }
2003                 }
2004             }
2005             else if ( parser.getName().equals( "excludes" )  )
2006             {
2007                 if ( parsed.contains( "excludes" ) )
2008                 {
2009                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2010                 }
2011                 parsed.add( "excludes" );
2012                 java.util.List excludes = new java.util.ArrayList();
2013                 fileSet.setExcludes( excludes );
2014                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2015                 {
2016                     if ( parser.getName().equals( "exclude" ) )
2017                     {
2018                         excludes.add( getTrimmedValue( parser.nextText()) );
2019                     }
2020                     else if ( strict )
2021                     {
2022                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2023                     }
2024                     else
2025                     {
2026                         // swallow up to end tag since this is not valid
2027                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2028                     }
2029                 }
2030             }
2031             else
2032             {
2033                 if ( strict )
2034                 {
2035                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2036                 }
2037                 else
2038                 {
2039                     // swallow up to end tag since this is not valid
2040                     while ( parser.next() != XmlPullParser.END_TAG ) {}
2041                 }
2042             }
2043         }
2044         return fileSet;
2045     } //-- FileSet parseFileSet( String, XmlPullParser, boolean ) 
2046 
2047     /**
2048      * Method parseIssueManagement.
2049      * 
2050      * @param tagName
2051      * @param strict
2052      * @param parser
2053      * @throws IOException
2054      * @throws XmlPullParserException
2055      * @return IssueManagement
2056      */
2057     private IssueManagement parseIssueManagement( String tagName, XmlPullParser parser, boolean strict )
2058         throws IOException, XmlPullParserException
2059     {
2060         IssueManagement issueManagement = new IssueManagement();
2061         java.util.Set parsed = new java.util.HashSet();
2062         while ( parser.nextTag() == XmlPullParser.START_TAG )
2063         {
2064             if ( parser.getName().equals( "system" )  )
2065             {
2066                 if ( parsed.contains( "system" ) )
2067                 {
2068                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2069                 }
2070                 parsed.add( "system" );
2071                 issueManagement.setSystem( getTrimmedValue( parser.nextText()) );
2072             }
2073             else if ( parser.getName().equals( "url" )  )
2074             {
2075                 if ( parsed.contains( "url" ) )
2076                 {
2077                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2078                 }
2079                 parsed.add( "url" );
2080                 issueManagement.setUrl( getTrimmedValue( parser.nextText()) );
2081             }
2082             else
2083             {
2084                 if ( strict )
2085                 {
2086                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2087                 }
2088                 else
2089                 {
2090                     // swallow up to end tag since this is not valid
2091                     while ( parser.next() != XmlPullParser.END_TAG ) {}
2092                 }
2093             }
2094         }
2095         return issueManagement;
2096     } //-- IssueManagement parseIssueManagement( String, XmlPullParser, boolean ) 
2097 
2098     /**
2099      * Method parseLicense.
2100      * 
2101      * @param tagName
2102      * @param strict
2103      * @param parser
2104      * @throws IOException
2105      * @throws XmlPullParserException
2106      * @return License
2107      */
2108     private License parseLicense( String tagName, XmlPullParser parser, boolean strict )
2109         throws IOException, XmlPullParserException
2110     {
2111         License license = new License();
2112         java.util.Set parsed = new java.util.HashSet();
2113         while ( parser.nextTag() == XmlPullParser.START_TAG )
2114         {
2115             if ( parser.getName().equals( "name" )  )
2116             {
2117                 if ( parsed.contains( "name" ) )
2118                 {
2119                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2120                 }
2121                 parsed.add( "name" );
2122                 license.setName( getTrimmedValue( parser.nextText()) );
2123             }
2124             else if ( parser.getName().equals( "url" )  )
2125             {
2126                 if ( parsed.contains( "url" ) )
2127                 {
2128                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2129                 }
2130                 parsed.add( "url" );
2131                 license.setUrl( getTrimmedValue( parser.nextText()) );
2132             }
2133             else if ( parser.getName().equals( "distribution" )  )
2134             {
2135                 if ( parsed.contains( "distribution" ) )
2136                 {
2137                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2138                 }
2139                 parsed.add( "distribution" );
2140                 license.setDistribution( getTrimmedValue( parser.nextText()) );
2141             }
2142             else if ( parser.getName().equals( "comments" )  )
2143             {
2144                 if ( parsed.contains( "comments" ) )
2145                 {
2146                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2147                 }
2148                 parsed.add( "comments" );
2149                 license.setComments( getTrimmedValue( parser.nextText()) );
2150             }
2151             else
2152             {
2153                 if ( strict )
2154                 {
2155                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2156                 }
2157                 else
2158                 {
2159                     // swallow up to end tag since this is not valid
2160                     while ( parser.next() != XmlPullParser.END_TAG ) {}
2161                 }
2162             }
2163         }
2164         return license;
2165     } //-- License parseLicense( String, XmlPullParser, boolean ) 
2166 
2167     /**
2168      * Method parseMailingList.
2169      * 
2170      * @param tagName
2171      * @param strict
2172      * @param parser
2173      * @throws IOException
2174      * @throws XmlPullParserException
2175      * @return MailingList
2176      */
2177     private MailingList parseMailingList( String tagName, XmlPullParser parser, boolean strict )
2178         throws IOException, XmlPullParserException
2179     {
2180         MailingList mailingList = new MailingList();
2181         java.util.Set parsed = new java.util.HashSet();
2182         while ( parser.nextTag() == XmlPullParser.START_TAG )
2183         {
2184             if ( parser.getName().equals( "name" )  )
2185             {
2186                 if ( parsed.contains( "name" ) )
2187                 {
2188                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2189                 }
2190                 parsed.add( "name" );
2191                 mailingList.setName( getTrimmedValue( parser.nextText()) );
2192             }
2193             else if ( parser.getName().equals( "subscribe" )  )
2194             {
2195                 if ( parsed.contains( "subscribe" ) )
2196                 {
2197                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2198                 }
2199                 parsed.add( "subscribe" );
2200                 mailingList.setSubscribe( getTrimmedValue( parser.nextText()) );
2201             }
2202             else if ( parser.getName().equals( "unsubscribe" )  )
2203             {
2204                 if ( parsed.contains( "unsubscribe" ) )
2205                 {
2206                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2207                 }
2208                 parsed.add( "unsubscribe" );
2209                 mailingList.setUnsubscribe( getTrimmedValue( parser.nextText()) );
2210             }
2211             else if ( parser.getName().equals( "post" )  )
2212             {
2213                 if ( parsed.contains( "post" ) )
2214                 {
2215                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2216                 }
2217                 parsed.add( "post" );
2218                 mailingList.setPost( getTrimmedValue( parser.nextText()) );
2219             }
2220             else if ( parser.getName().equals( "archive" )  )
2221             {
2222                 if ( parsed.contains( "archive" ) )
2223                 {
2224                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2225                 }
2226                 parsed.add( "archive" );
2227                 mailingList.setArchive( getTrimmedValue( parser.nextText()) );
2228             }
2229             else if ( parser.getName().equals( "otherArchives" )  )
2230             {
2231                 if ( parsed.contains( "otherArchives" ) )
2232                 {
2233                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2234                 }
2235                 parsed.add( "otherArchives" );
2236                 java.util.List otherArchives = new java.util.ArrayList();
2237                 mailingList.setOtherArchives( otherArchives );
2238                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2239                 {
2240                     if ( parser.getName().equals( "otherArchive" ) )
2241                     {
2242                         otherArchives.add( getTrimmedValue( parser.nextText()) );
2243                     }
2244                     else if ( strict )
2245                     {
2246                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2247                     }
2248                     else
2249                     {
2250                         // swallow up to end tag since this is not valid
2251                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2252                     }
2253                 }
2254             }
2255             else
2256             {
2257                 if ( strict )
2258                 {
2259                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2260                 }
2261                 else
2262                 {
2263                     // swallow up to end tag since this is not valid
2264                     while ( parser.next() != XmlPullParser.END_TAG ) {}
2265                 }
2266             }
2267         }
2268         return mailingList;
2269     } //-- MailingList parseMailingList( String, XmlPullParser, boolean ) 
2270 
2271     /**
2272      * Method parseModel.
2273      * 
2274      * @param tagName
2275      * @param strict
2276      * @param parser
2277      * @throws IOException
2278      * @throws XmlPullParserException
2279      * @return Model
2280      */
2281     private Model parseModel( String tagName, XmlPullParser parser, boolean strict )
2282         throws IOException, XmlPullParserException
2283     {
2284         Model model = new Model();
2285         java.util.Set parsed = new java.util.HashSet();
2286         int eventType = parser.getEventType();
2287         boolean foundRoot = false;
2288         while ( eventType != XmlPullParser.END_DOCUMENT )
2289         {
2290             if ( eventType == XmlPullParser.START_TAG )
2291             {
2292                 if ( parser.getName().equals( tagName ) )
2293                 {
2294                     foundRoot = true;
2295                 }
2296                 else if ( parser.getName().equals( "modelVersion" )  )
2297                 {
2298                     if ( parsed.contains( "modelVersion" ) )
2299                     {
2300                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2301                     }
2302                     parsed.add( "modelVersion" );
2303                     model.setModelVersion( getTrimmedValue( parser.nextText()) );
2304                 }
2305                 else if ( parser.getName().equals( "parent" )  )
2306                 {
2307                     if ( parsed.contains( "parent" ) )
2308                     {
2309                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2310                     }
2311                     parsed.add( "parent" );
2312                     model.setParent( parseParent( "parent", parser, strict ) );
2313                 }
2314                 else if ( parser.getName().equals( "groupId" )  )
2315                 {
2316                     if ( parsed.contains( "groupId" ) )
2317                     {
2318                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2319                     }
2320                     parsed.add( "groupId" );
2321                     model.setGroupId( getTrimmedValue( parser.nextText()) );
2322                 }
2323                 else if ( parser.getName().equals( "artifactId" )  )
2324                 {
2325                     if ( parsed.contains( "artifactId" ) )
2326                     {
2327                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2328                     }
2329                     parsed.add( "artifactId" );
2330                     model.setArtifactId( getTrimmedValue( parser.nextText()) );
2331                 }
2332                 else if ( parser.getName().equals( "version" )  )
2333                 {
2334                     if ( parsed.contains( "version" ) )
2335                     {
2336                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2337                     }
2338                     parsed.add( "version" );
2339                     model.setVersion( getTrimmedValue( parser.nextText()) );
2340                 }
2341                 else if ( parser.getName().equals( "packaging" )  )
2342                 {
2343                     if ( parsed.contains( "packaging" ) )
2344                     {
2345                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2346                     }
2347                     parsed.add( "packaging" );
2348                     model.setPackaging( getTrimmedValue( parser.nextText()) );
2349                 }
2350                 else if ( parser.getName().equals( "name" )  )
2351                 {
2352                     if ( parsed.contains( "name" ) )
2353                     {
2354                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2355                     }
2356                     parsed.add( "name" );
2357                     model.setName( getTrimmedValue( parser.nextText()) );
2358                 }
2359                 else if ( parser.getName().equals( "description" )  )
2360                 {
2361                     if ( parsed.contains( "description" ) )
2362                     {
2363                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2364                     }
2365                     parsed.add( "description" );
2366                     model.setDescription( getTrimmedValue( parser.nextText()) );
2367                 }
2368                 else if ( parser.getName().equals( "url" )  )
2369                 {
2370                     if ( parsed.contains( "url" ) )
2371                     {
2372                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2373                     }
2374                     parsed.add( "url" );
2375                     model.setUrl( getTrimmedValue( parser.nextText()) );
2376                 }
2377                 else if ( parser.getName().equals( "inceptionYear" )  )
2378                 {
2379                     if ( parsed.contains( "inceptionYear" ) )
2380                     {
2381                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2382                     }
2383                     parsed.add( "inceptionYear" );
2384                     model.setInceptionYear( getTrimmedValue( parser.nextText()) );
2385                 }
2386                 else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" )  )
2387                 {
2388                     if ( parsed.contains( "organization" ) )
2389                     {
2390                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2391                     }
2392                     parsed.add( "organization" );
2393                     model.setOrganization( parseOrganization( "organization", parser, strict ) );
2394                 }
2395                 else if ( parser.getName().equals( "licenses" )  )
2396                 {
2397                     if ( parsed.contains( "licenses" ) )
2398                     {
2399                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2400                     }
2401                     parsed.add( "licenses" );
2402                     java.util.List licenses = new java.util.ArrayList();
2403                     model.setLicenses( licenses );
2404                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2405                     {
2406                         if ( parser.getName().equals( "license" ) )
2407                         {
2408                             licenses.add( parseLicense( "license", parser, strict ) );
2409                         }
2410                         else if ( strict )
2411                         {
2412                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2413                         }
2414                         else
2415                         {
2416                             // swallow up to end tag since this is not valid
2417                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2418                         }
2419                     }
2420                 }
2421                 else if ( parser.getName().equals( "mailingLists" )  )
2422                 {
2423                     if ( parsed.contains( "mailingLists" ) )
2424                     {
2425                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2426                     }
2427                     parsed.add( "mailingLists" );
2428                     java.util.List mailingLists = new java.util.ArrayList();
2429                     model.setMailingLists( mailingLists );
2430                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2431                     {
2432                         if ( parser.getName().equals( "mailingList" ) )
2433                         {
2434                             mailingLists.add( parseMailingList( "mailingList", parser, strict ) );
2435                         }
2436                         else if ( strict )
2437                         {
2438                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2439                         }
2440                         else
2441                         {
2442                             // swallow up to end tag since this is not valid
2443                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2444                         }
2445                     }
2446                 }
2447                 else if ( parser.getName().equals( "developers" )  )
2448                 {
2449                     if ( parsed.contains( "developers" ) )
2450                     {
2451                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2452                     }
2453                     parsed.add( "developers" );
2454                     java.util.List developers = new java.util.ArrayList();
2455                     model.setDevelopers( developers );
2456                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2457                     {
2458                         if ( parser.getName().equals( "developer" ) )
2459                         {
2460                             developers.add( parseDeveloper( "developer", parser, strict ) );
2461                         }
2462                         else if ( strict )
2463                         {
2464                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2465                         }
2466                         else
2467                         {
2468                             // swallow up to end tag since this is not valid
2469                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2470                         }
2471                     }
2472                 }
2473                 else if ( parser.getName().equals( "contributors" )  )
2474                 {
2475                     if ( parsed.contains( "contributors" ) )
2476                     {
2477                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2478                     }
2479                     parsed.add( "contributors" );
2480                     java.util.List contributors = new java.util.ArrayList();
2481                     model.setContributors( contributors );
2482                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2483                     {
2484                         if ( parser.getName().equals( "contributor" ) )
2485                         {
2486                             contributors.add( parseContributor( "contributor", parser, strict ) );
2487                         }
2488                         else if ( strict )
2489                         {
2490                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2491                         }
2492                         else
2493                         {
2494                             // swallow up to end tag since this is not valid
2495                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2496                         }
2497                     }
2498                 }
2499                 else if ( parser.getName().equals( "issueManagement" )  )
2500                 {
2501                     if ( parsed.contains( "issueManagement" ) )
2502                     {
2503                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2504                     }
2505                     parsed.add( "issueManagement" );
2506                     model.setIssueManagement( parseIssueManagement( "issueManagement", parser, strict ) );
2507                 }
2508                 else if ( parser.getName().equals( "scm" )  )
2509                 {
2510                     if ( parsed.contains( "scm" ) )
2511                     {
2512                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2513                     }
2514                     parsed.add( "scm" );
2515                     model.setScm( parseScm( "scm", parser, strict ) );
2516                 }
2517                 else if ( parser.getName().equals( "ciManagement" )  )
2518                 {
2519                     if ( parsed.contains( "ciManagement" ) )
2520                     {
2521                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2522                     }
2523                     parsed.add( "ciManagement" );
2524                     model.setCiManagement( parseCiManagement( "ciManagement", parser, strict ) );
2525                 }
2526                 else if ( parser.getName().equals( "prerequisites" )  )
2527                 {
2528                     if ( parsed.contains( "prerequisites" ) )
2529                     {
2530                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2531                     }
2532                     parsed.add( "prerequisites" );
2533                     model.setPrerequisites( parsePrerequisites( "prerequisites", parser, strict ) );
2534                 }
2535                 else if ( parser.getName().equals( "build" )  )
2536                 {
2537                     if ( parsed.contains( "build" ) )
2538                     {
2539                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2540                     }
2541                     parsed.add( "build" );
2542                     model.setBuild( parseBuild( "build", parser, strict ) );
2543                 }
2544                 else if ( parser.getName().equals( "profiles" )  )
2545                 {
2546                     if ( parsed.contains( "profiles" ) )
2547                     {
2548                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2549                     }
2550                     parsed.add( "profiles" );
2551                     java.util.List profiles = new java.util.ArrayList();
2552                     model.setProfiles( profiles );
2553                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2554                     {
2555                         if ( parser.getName().equals( "profile" ) )
2556                         {
2557                             profiles.add( parseProfile( "profile", parser, strict ) );
2558                         }
2559                         else if ( strict )
2560                         {
2561                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2562                         }
2563                         else
2564                         {
2565                             // swallow up to end tag since this is not valid
2566                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2567                         }
2568                     }
2569                 }
2570                 else if ( parser.getName().equals( "distributionManagement" )  )
2571                 {
2572                     if ( parsed.contains( "distributionManagement" ) )
2573                     {
2574                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2575                     }
2576                     parsed.add( "distributionManagement" );
2577                     model.setDistributionManagement( parseDistributionManagement( "distributionManagement", parser, strict ) );
2578                 }
2579                 else if ( parser.getName().equals( "modules" )  )
2580                 {
2581                     if ( parsed.contains( "modules" ) )
2582                     {
2583                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2584                     }
2585                     parsed.add( "modules" );
2586                     java.util.List modules = new java.util.ArrayList();
2587                     model.setModules( modules );
2588                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2589                     {
2590                         if ( parser.getName().equals( "module" ) )
2591                         {
2592                             modules.add( getTrimmedValue( parser.nextText()) );
2593                         }
2594                         else if ( strict )
2595                         {
2596                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2597                         }
2598                         else
2599                         {
2600                             // swallow up to end tag since this is not valid
2601                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2602                         }
2603                     }
2604                 }
2605                 else if ( parser.getName().equals( "repositories" )  )
2606                 {
2607                     if ( parsed.contains( "repositories" ) )
2608                     {
2609                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2610                     }
2611                     parsed.add( "repositories" );
2612                     java.util.List repositories = new java.util.ArrayList();
2613                     model.setRepositories( repositories );
2614                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2615                     {
2616                         if ( parser.getName().equals( "repository" ) )
2617                         {
2618                             repositories.add( parseRepository( "repository", parser, strict ) );
2619                         }
2620                         else if ( strict )
2621                         {
2622                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2623                         }
2624                         else
2625                         {
2626                             // swallow up to end tag since this is not valid
2627                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2628                         }
2629                     }
2630                 }
2631                 else if ( parser.getName().equals( "pluginRepositories" )  )
2632                 {
2633                     if ( parsed.contains( "pluginRepositories" ) )
2634                     {
2635                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2636                     }
2637                     parsed.add( "pluginRepositories" );
2638                     java.util.List pluginRepositories = new java.util.ArrayList();
2639                     model.setPluginRepositories( pluginRepositories );
2640                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2641                     {
2642                         if ( parser.getName().equals( "pluginRepository" ) )
2643                         {
2644                             pluginRepositories.add( parseRepository( "pluginRepository", parser, strict ) );
2645                         }
2646                         else if ( strict )
2647                         {
2648                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2649                         }
2650                         else
2651                         {
2652                             // swallow up to end tag since this is not valid
2653                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2654                         }
2655                     }
2656                 }
2657                 else if ( parser.getName().equals( "dependencies" )  )
2658                 {
2659                     if ( parsed.contains( "dependencies" ) )
2660                     {
2661                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2662                     }
2663                     parsed.add( "dependencies" );
2664                     java.util.List dependencies = new java.util.ArrayList();
2665                     model.setDependencies( dependencies );
2666                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2667                     {
2668                         if ( parser.getName().equals( "dependency" ) )
2669                         {
2670                             dependencies.add( parseDependency( "dependency", parser, strict ) );
2671                         }
2672                         else if ( strict )
2673                         {
2674                             throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2675                         }
2676                         else
2677                         {
2678                             // swallow up to end tag since this is not valid
2679                             while ( parser.next() != XmlPullParser.END_TAG ) {}
2680                         }
2681                     }
2682                 }
2683                 else if ( parser.getName().equals( "reports" )  )
2684                 {
2685                     if ( parsed.contains( "reports" ) )
2686                     {
2687                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2688                     }
2689                     parsed.add( "reports" );
2690                     model.setReports( Xpp3DomBuilder.build( parser ) );
2691                 }
2692                 else if ( parser.getName().equals( "reporting" )  )
2693                 {
2694                     if ( parsed.contains( "reporting" ) )
2695                     {
2696                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2697                     }
2698                     parsed.add( "reporting" );
2699                     model.setReporting( parseReporting( "reporting", parser, strict ) );
2700                 }
2701                 else if ( parser.getName().equals( "dependencyManagement" )  )
2702                 {
2703                     if ( parsed.contains( "dependencyManagement" ) )
2704                     {
2705                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2706                     }
2707                     parsed.add( "dependencyManagement" );
2708                     model.setDependencyManagement( parseDependencyManagement( "dependencyManagement", parser, strict ) );
2709                 }
2710                 else if ( parser.getName().equals( "properties" )  )
2711                 {
2712                     if ( parsed.contains( "properties" ) )
2713                     {
2714                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2715                     }
2716                     parsed.add( "properties" );
2717                     while ( parser.nextTag() == XmlPullParser.START_TAG )
2718                     {
2719                         String key = parser.getName();
2720                         String value = parser.nextText().trim();
2721                         model.addProperty( key, value );
2722                     }
2723                 }
2724                 else if ( strict )
2725                 {
2726                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2727                 }
2728             }
2729             eventType = parser.next();
2730         }
2731         return model;
2732     } //-- Model parseModel( String, XmlPullParser, boolean ) 
2733 
2734     /**
2735      * Method parseModelBase.
2736      * 
2737      * @param tagName
2738      * @param strict
2739      * @param parser
2740      * @throws IOException
2741      * @throws XmlPullParserException
2742      * @return ModelBase
2743      */
2744     private ModelBase parseModelBase( String tagName, XmlPullParser parser, boolean strict )
2745         throws IOException, XmlPullParserException
2746     {
2747         ModelBase modelBase = new ModelBase();
2748         java.util.Set parsed = new java.util.HashSet();
2749         while ( parser.nextTag() == XmlPullParser.START_TAG )
2750         {
2751             if ( parser.getName().equals( "distributionManagement" )  )
2752             {
2753                 if ( parsed.contains( "distributionManagement" ) )
2754                 {
2755                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2756                 }
2757                 parsed.add( "distributionManagement" );
2758                 modelBase.setDistributionManagement( parseDistributionManagement( "distributionManagement", parser, strict ) );
2759             }
2760             else if ( parser.getName().equals( "modules" )  )
2761             {
2762                 if ( parsed.contains( "modules" ) )
2763                 {
2764                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2765                 }
2766                 parsed.add( "modules" );
2767                 java.util.List modules = new java.util.ArrayList();
2768                 modelBase.setModules( modules );
2769                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2770                 {
2771                     if ( parser.getName().equals( "module" ) )
2772                     {
2773                         modules.add( getTrimmedValue( parser.nextText()) );
2774                     }
2775                     else if ( strict )
2776                     {
2777                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2778                     }
2779                     else
2780                     {
2781                         // swallow up to end tag since this is not valid
2782                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2783                     }
2784                 }
2785             }
2786             else if ( parser.getName().equals( "repositories" )  )
2787             {
2788                 if ( parsed.contains( "repositories" ) )
2789                 {
2790                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2791                 }
2792                 parsed.add( "repositories" );
2793                 java.util.List repositories = new java.util.ArrayList();
2794                 modelBase.setRepositories( repositories );
2795                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2796                 {
2797                     if ( parser.getName().equals( "repository" ) )
2798                     {
2799                         repositories.add( parseRepository( "repository", parser, strict ) );
2800                     }
2801                     else if ( strict )
2802                     {
2803                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2804                     }
2805                     else
2806                     {
2807                         // swallow up to end tag since this is not valid
2808                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2809                     }
2810                 }
2811             }
2812             else if ( parser.getName().equals( "pluginRepositories" )  )
2813             {
2814                 if ( parsed.contains( "pluginRepositories" ) )
2815                 {
2816                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2817                 }
2818                 parsed.add( "pluginRepositories" );
2819                 java.util.List pluginRepositories = new java.util.ArrayList();
2820                 modelBase.setPluginRepositories( pluginRepositories );
2821                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2822                 {
2823                     if ( parser.getName().equals( "pluginRepository" ) )
2824                     {
2825                         pluginRepositories.add( parseRepository( "pluginRepository", parser, strict ) );
2826                     }
2827                     else if ( strict )
2828                     {
2829                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2830                     }
2831                     else
2832                     {
2833                         // swallow up to end tag since this is not valid
2834                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2835                     }
2836                 }
2837             }
2838             else if ( parser.getName().equals( "dependencies" )  )
2839             {
2840                 if ( parsed.contains( "dependencies" ) )
2841                 {
2842                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2843                 }
2844                 parsed.add( "dependencies" );
2845                 java.util.List dependencies = new java.util.ArrayList();
2846                 modelBase.setDependencies( dependencies );
2847                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2848                 {
2849                     if ( parser.getName().equals( "dependency" ) )
2850                     {
2851                         dependencies.add( parseDependency( "dependency", parser, strict ) );
2852                     }
2853                     else if ( strict )
2854                     {
2855                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
2856                     }
2857                     else
2858                     {
2859                         // swallow up to end tag since this is not valid
2860                         while ( parser.next() != XmlPullParser.END_TAG ) {}
2861                     }
2862                 }
2863             }
2864             else if ( parser.getName().equals( "reports" )  )
2865             {
2866                 if ( parsed.contains( "reports" ) )
2867                 {
2868                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2869                 }
2870                 parsed.add( "reports" );
2871                 modelBase.setReports( Xpp3DomBuilder.build( parser ) );
2872             }
2873             else if ( parser.getName().equals( "reporting" )  )
2874             {
2875                 if ( parsed.contains( "reporting" ) )
2876                 {
2877                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2878                 }
2879                 parsed.add( "reporting" );
2880                 modelBase.setReporting( parseReporting( "reporting", parser, strict ) );
2881             }
2882             else if ( parser.getName().equals( "dependencyManagement" )  )
2883             {
2884                 if ( parsed.contains( "dependencyManagement" ) )
2885                 {
2886                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2887                 }
2888                 parsed.add( "dependencyManagement" );
2889                 modelBase.setDependencyManagement( parseDependencyManagement( "dependencyManagement", parser, strict ) );
2890             }
2891             else if ( parser.getName().equals( "properties" )  )
2892             {
2893                 if ( parsed.contains( "properties" ) )
2894                 {
2895                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2896                 }
2897                 parsed.add( "properties" );
2898                 while ( parser.nextTag() == XmlPullParser.START_TAG )
2899                 {
2900                     String key = parser.getName();
2901                     String value = parser.nextText().trim();
2902                     modelBase.addProperty( key, value );
2903                 }
2904             }
2905             else
2906             {
2907                 if ( strict )
2908                 {
2909                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
2910                 }
2911                 else
2912                 {
2913                     // swallow up to end tag since this is not valid
2914                     while ( parser.next() != XmlPullParser.END_TAG ) {}
2915                 }
2916             }
2917         }
2918         return modelBase;
2919     } //-- ModelBase parseModelBase( String, XmlPullParser, boolean ) 
2920 
2921     /**
2922      * Method parseNotifier.
2923      * 
2924      * @param tagName
2925      * @param strict
2926      * @param parser
2927      * @throws IOException
2928      * @throws XmlPullParserException
2929      * @return Notifier
2930      */
2931     private Notifier parseNotifier( String tagName, XmlPullParser parser, boolean strict )
2932         throws IOException, XmlPullParserException
2933     {
2934         Notifier notifier = new Notifier();
2935         java.util.Set parsed = new java.util.HashSet();
2936         while ( parser.nextTag() == XmlPullParser.START_TAG )
2937         {
2938             if ( parser.getName().equals( "type" )  )
2939             {
2940                 if ( parsed.contains( "type" ) )
2941                 {
2942                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2943                 }
2944                 parsed.add( "type" );
2945                 notifier.setType( getTrimmedValue( parser.nextText()) );
2946             }
2947             else if ( parser.getName().equals( "sendOnError" )  )
2948             {
2949                 if ( parsed.contains( "sendOnError" ) )
2950                 {
2951                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2952                 }
2953                 parsed.add( "sendOnError" );
2954                 notifier.setSendOnError( getBooleanValue( getTrimmedValue( parser.nextText()), "sendOnError", parser, "true" ) );
2955             }
2956             else if ( parser.getName().equals( "sendOnFailure" )  )
2957             {
2958                 if ( parsed.contains( "sendOnFailure" ) )
2959                 {
2960                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2961                 }
2962                 parsed.add( "sendOnFailure" );
2963                 notifier.setSendOnFailure( getBooleanValue( getTrimmedValue( parser.nextText()), "sendOnFailure", parser, "true" ) );
2964             }
2965             else if ( parser.getName().equals( "sendOnSuccess" )  )
2966             {
2967                 if ( parsed.contains( "sendOnSuccess" ) )
2968                 {
2969                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2970                 }
2971                 parsed.add( "sendOnSuccess" );
2972                 notifier.setSendOnSuccess( getBooleanValue( getTrimmedValue( parser.nextText()), "sendOnSuccess", parser, "true" ) );
2973             }
2974             else if ( parser.getName().equals( "sendOnWarning" )  )
2975             {
2976                 if ( parsed.contains( "sendOnWarning" ) )
2977                 {
2978                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2979                 }
2980                 parsed.add( "sendOnWarning" );
2981                 notifier.setSendOnWarning( getBooleanValue( getTrimmedValue( parser.nextText()), "sendOnWarning", parser, "true" ) );
2982             }
2983             else if ( parser.getName().equals( "address" )  )
2984             {
2985                 if ( parsed.contains( "address" ) )
2986                 {
2987                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2988                 }
2989                 parsed.add( "address" );
2990                 notifier.setAddress( getTrimmedValue( parser.nextText()) );
2991             }
2992             else if ( parser.getName().equals( "configuration" )  )
2993             {
2994                 if ( parsed.contains( "configuration" ) )
2995                 {
2996                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
2997                 }
2998                 parsed.add( "configuration" );
2999                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3000                 {
3001                     String key = parser.getName();
3002                     String value = parser.nextText().trim();
3003                     notifier.addConfiguration( key, value );
3004                 }
3005             }
3006             else
3007             {
3008                 if ( strict )
3009                 {
3010                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3011                 }
3012                 else
3013                 {
3014                     // swallow up to end tag since this is not valid
3015                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3016                 }
3017             }
3018         }
3019         return notifier;
3020     } //-- Notifier parseNotifier( String, XmlPullParser, boolean ) 
3021 
3022     /**
3023      * Method parseOrganization.
3024      * 
3025      * @param tagName
3026      * @param strict
3027      * @param parser
3028      * @throws IOException
3029      * @throws XmlPullParserException
3030      * @return Organization
3031      */
3032     private Organization parseOrganization( String tagName, XmlPullParser parser, boolean strict )
3033         throws IOException, XmlPullParserException
3034     {
3035         Organization organization = new Organization();
3036         java.util.Set parsed = new java.util.HashSet();
3037         while ( parser.nextTag() == XmlPullParser.START_TAG )
3038         {
3039             if ( parser.getName().equals( "name" )  )
3040             {
3041                 if ( parsed.contains( "name" ) )
3042                 {
3043                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3044                 }
3045                 parsed.add( "name" );
3046                 organization.setName( getTrimmedValue( parser.nextText()) );
3047             }
3048             else if ( parser.getName().equals( "url" )  )
3049             {
3050                 if ( parsed.contains( "url" ) )
3051                 {
3052                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3053                 }
3054                 parsed.add( "url" );
3055                 organization.setUrl( getTrimmedValue( parser.nextText()) );
3056             }
3057             else
3058             {
3059                 if ( strict )
3060                 {
3061                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3062                 }
3063                 else
3064                 {
3065                     // swallow up to end tag since this is not valid
3066                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3067                 }
3068             }
3069         }
3070         return organization;
3071     } //-- Organization parseOrganization( String, XmlPullParser, boolean ) 
3072 
3073     /**
3074      * Method parseParent.
3075      * 
3076      * @param tagName
3077      * @param strict
3078      * @param parser
3079      * @throws IOException
3080      * @throws XmlPullParserException
3081      * @return Parent
3082      */
3083     private Parent parseParent( String tagName, XmlPullParser parser, boolean strict )
3084         throws IOException, XmlPullParserException
3085     {
3086         Parent parent = new Parent();
3087         java.util.Set parsed = new java.util.HashSet();
3088         while ( parser.nextTag() == XmlPullParser.START_TAG )
3089         {
3090             if ( parser.getName().equals( "artifactId" )  )
3091             {
3092                 if ( parsed.contains( "artifactId" ) )
3093                 {
3094                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3095                 }
3096                 parsed.add( "artifactId" );
3097                 parent.setArtifactId( getTrimmedValue( parser.nextText()) );
3098             }
3099             else if ( parser.getName().equals( "groupId" )  )
3100             {
3101                 if ( parsed.contains( "groupId" ) )
3102                 {
3103                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3104                 }
3105                 parsed.add( "groupId" );
3106                 parent.setGroupId( getTrimmedValue( parser.nextText()) );
3107             }
3108             else if ( parser.getName().equals( "version" )  )
3109             {
3110                 if ( parsed.contains( "version" ) )
3111                 {
3112                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3113                 }
3114                 parsed.add( "version" );
3115                 parent.setVersion( getTrimmedValue( parser.nextText()) );
3116             }
3117             else if ( parser.getName().equals( "relativePath" )  )
3118             {
3119                 if ( parsed.contains( "relativePath" ) )
3120                 {
3121                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3122                 }
3123                 parsed.add( "relativePath" );
3124                 parent.setRelativePath( getTrimmedValue( parser.nextText()) );
3125             }
3126             else
3127             {
3128                 if ( strict )
3129                 {
3130                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3131                 }
3132                 else
3133                 {
3134                     // swallow up to end tag since this is not valid
3135                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3136                 }
3137             }
3138         }
3139         return parent;
3140     } //-- Parent parseParent( String, XmlPullParser, boolean ) 
3141 
3142     /**
3143      * Method parsePatternSet.
3144      * 
3145      * @param tagName
3146      * @param strict
3147      * @param parser
3148      * @throws IOException
3149      * @throws XmlPullParserException
3150      * @return PatternSet
3151      */
3152     private PatternSet parsePatternSet( String tagName, XmlPullParser parser, boolean strict )
3153         throws IOException, XmlPullParserException
3154     {
3155         PatternSet patternSet = new PatternSet();
3156         java.util.Set parsed = new java.util.HashSet();
3157         while ( parser.nextTag() == XmlPullParser.START_TAG )
3158         {
3159             if ( parser.getName().equals( "includes" )  )
3160             {
3161                 if ( parsed.contains( "includes" ) )
3162                 {
3163                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3164                 }
3165                 parsed.add( "includes" );
3166                 java.util.List includes = new java.util.ArrayList();
3167                 patternSet.setIncludes( includes );
3168                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3169                 {
3170                     if ( parser.getName().equals( "include" ) )
3171                     {
3172                         includes.add( getTrimmedValue( parser.nextText()) );
3173                     }
3174                     else if ( strict )
3175                     {
3176                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3177                     }
3178                     else
3179                     {
3180                         // swallow up to end tag since this is not valid
3181                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3182                     }
3183                 }
3184             }
3185             else if ( parser.getName().equals( "excludes" )  )
3186             {
3187                 if ( parsed.contains( "excludes" ) )
3188                 {
3189                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3190                 }
3191                 parsed.add( "excludes" );
3192                 java.util.List excludes = new java.util.ArrayList();
3193                 patternSet.setExcludes( excludes );
3194                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3195                 {
3196                     if ( parser.getName().equals( "exclude" ) )
3197                     {
3198                         excludes.add( getTrimmedValue( parser.nextText()) );
3199                     }
3200                     else if ( strict )
3201                     {
3202                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3203                     }
3204                     else
3205                     {
3206                         // swallow up to end tag since this is not valid
3207                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3208                     }
3209                 }
3210             }
3211             else
3212             {
3213                 if ( strict )
3214                 {
3215                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3216                 }
3217                 else
3218                 {
3219                     // swallow up to end tag since this is not valid
3220                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3221                 }
3222             }
3223         }
3224         return patternSet;
3225     } //-- PatternSet parsePatternSet( String, XmlPullParser, boolean ) 
3226 
3227     /**
3228      * Method parsePlugin.
3229      * 
3230      * @param tagName
3231      * @param strict
3232      * @param parser
3233      * @throws IOException
3234      * @throws XmlPullParserException
3235      * @return Plugin
3236      */
3237     private Plugin parsePlugin( String tagName, XmlPullParser parser, boolean strict )
3238         throws IOException, XmlPullParserException
3239     {
3240         Plugin plugin = new Plugin();
3241         java.util.Set parsed = new java.util.HashSet();
3242         while ( parser.nextTag() == XmlPullParser.START_TAG )
3243         {
3244             if ( parser.getName().equals( "groupId" )  )
3245             {
3246                 if ( parsed.contains( "groupId" ) )
3247                 {
3248                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3249                 }
3250                 parsed.add( "groupId" );
3251                 plugin.setGroupId( getTrimmedValue( parser.nextText()) );
3252             }
3253             else if ( parser.getName().equals( "artifactId" )  )
3254             {
3255                 if ( parsed.contains( "artifactId" ) )
3256                 {
3257                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3258                 }
3259                 parsed.add( "artifactId" );
3260                 plugin.setArtifactId( getTrimmedValue( parser.nextText()) );
3261             }
3262             else if ( parser.getName().equals( "version" )  )
3263             {
3264                 if ( parsed.contains( "version" ) )
3265                 {
3266                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3267                 }
3268                 parsed.add( "version" );
3269                 plugin.setVersion( getTrimmedValue( parser.nextText()) );
3270             }
3271             else if ( parser.getName().equals( "extensions" )  )
3272             {
3273                 if ( parsed.contains( "extensions" ) )
3274                 {
3275                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3276                 }
3277                 parsed.add( "extensions" );
3278                 plugin.setExtensions( getBooleanValue( getTrimmedValue( parser.nextText()), "extensions", parser, "false" ) );
3279             }
3280             else if ( parser.getName().equals( "executions" )  )
3281             {
3282                 if ( parsed.contains( "executions" ) )
3283                 {
3284                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3285                 }
3286                 parsed.add( "executions" );
3287                 java.util.List executions = new java.util.ArrayList();
3288                 plugin.setExecutions( executions );
3289                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3290                 {
3291                     if ( parser.getName().equals( "execution" ) )
3292                     {
3293                         executions.add( parsePluginExecution( "execution", parser, strict ) );
3294                     }
3295                     else if ( strict )
3296                     {
3297                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3298                     }
3299                     else
3300                     {
3301                         // swallow up to end tag since this is not valid
3302                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3303                     }
3304                 }
3305             }
3306             else if ( parser.getName().equals( "dependencies" )  )
3307             {
3308                 if ( parsed.contains( "dependencies" ) )
3309                 {
3310                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3311                 }
3312                 parsed.add( "dependencies" );
3313                 java.util.List dependencies = new java.util.ArrayList();
3314                 plugin.setDependencies( dependencies );
3315                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3316                 {
3317                     if ( parser.getName().equals( "dependency" ) )
3318                     {
3319                         dependencies.add( parseDependency( "dependency", parser, strict ) );
3320                     }
3321                     else if ( strict )
3322                     {
3323                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3324                     }
3325                     else
3326                     {
3327                         // swallow up to end tag since this is not valid
3328                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3329                     }
3330                 }
3331             }
3332             else if ( parser.getName().equals( "goals" )  )
3333             {
3334                 if ( parsed.contains( "goals" ) )
3335                 {
3336                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3337                 }
3338                 parsed.add( "goals" );
3339                 plugin.setGoals( Xpp3DomBuilder.build( parser ) );
3340             }
3341             else if ( parser.getName().equals( "inherited" )  )
3342             {
3343                 if ( parsed.contains( "inherited" ) )
3344                 {
3345                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3346                 }
3347                 parsed.add( "inherited" );
3348                 plugin.setInherited( getTrimmedValue( parser.nextText()) );
3349             }
3350             else if ( parser.getName().equals( "configuration" )  )
3351             {
3352                 if ( parsed.contains( "configuration" ) )
3353                 {
3354                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3355                 }
3356                 parsed.add( "configuration" );
3357                 plugin.setConfiguration( Xpp3DomBuilder.build( parser ) );
3358             }
3359             else
3360             {
3361                 if ( strict )
3362                 {
3363                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3364                 }
3365                 else
3366                 {
3367                     // swallow up to end tag since this is not valid
3368                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3369                 }
3370             }
3371         }
3372         return plugin;
3373     } //-- Plugin parsePlugin( String, XmlPullParser, boolean ) 
3374 
3375     /**
3376      * Method parsePluginConfiguration.
3377      * 
3378      * @param tagName
3379      * @param strict
3380      * @param parser
3381      * @throws IOException
3382      * @throws XmlPullParserException
3383      * @return PluginConfiguration
3384      */
3385     private PluginConfiguration parsePluginConfiguration( String tagName, XmlPullParser parser, boolean strict )
3386         throws IOException, XmlPullParserException
3387     {
3388         PluginConfiguration pluginConfiguration = new PluginConfiguration();
3389         java.util.Set parsed = new java.util.HashSet();
3390         while ( parser.nextTag() == XmlPullParser.START_TAG )
3391         {
3392             if ( parser.getName().equals( "pluginManagement" )  )
3393             {
3394                 if ( parsed.contains( "pluginManagement" ) )
3395                 {
3396                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3397                 }
3398                 parsed.add( "pluginManagement" );
3399                 pluginConfiguration.setPluginManagement( parsePluginManagement( "pluginManagement", parser, strict ) );
3400             }
3401             else if ( parser.getName().equals( "plugins" )  )
3402             {
3403                 if ( parsed.contains( "plugins" ) )
3404                 {
3405                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3406                 }
3407                 parsed.add( "plugins" );
3408                 java.util.List plugins = new java.util.ArrayList();
3409                 pluginConfiguration.setPlugins( plugins );
3410                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3411                 {
3412                     if ( parser.getName().equals( "plugin" ) )
3413                     {
3414                         plugins.add( parsePlugin( "plugin", parser, strict ) );
3415                     }
3416                     else if ( strict )
3417                     {
3418                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3419                     }
3420                     else
3421                     {
3422                         // swallow up to end tag since this is not valid
3423                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3424                     }
3425                 }
3426             }
3427             else
3428             {
3429                 if ( strict )
3430                 {
3431                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3432                 }
3433                 else
3434                 {
3435                     // swallow up to end tag since this is not valid
3436                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3437                 }
3438             }
3439         }
3440         return pluginConfiguration;
3441     } //-- PluginConfiguration parsePluginConfiguration( String, XmlPullParser, boolean ) 
3442 
3443     /**
3444      * Method parsePluginContainer.
3445      * 
3446      * @param tagName
3447      * @param strict
3448      * @param parser
3449      * @throws IOException
3450      * @throws XmlPullParserException
3451      * @return PluginContainer
3452      */
3453     private PluginContainer parsePluginContainer( String tagName, XmlPullParser parser, boolean strict )
3454         throws IOException, XmlPullParserException
3455     {
3456         PluginContainer pluginContainer = new PluginContainer();
3457         java.util.Set parsed = new java.util.HashSet();
3458         while ( parser.nextTag() == XmlPullParser.START_TAG )
3459         {
3460             if ( parser.getName().equals( "plugins" )  )
3461             {
3462                 if ( parsed.contains( "plugins" ) )
3463                 {
3464                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3465                 }
3466                 parsed.add( "plugins" );
3467                 java.util.List plugins = new java.util.ArrayList();
3468                 pluginContainer.setPlugins( plugins );
3469                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3470                 {
3471                     if ( parser.getName().equals( "plugin" ) )
3472                     {
3473                         plugins.add( parsePlugin( "plugin", parser, strict ) );
3474                     }
3475                     else if ( strict )
3476                     {
3477                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3478                     }
3479                     else
3480                     {
3481                         // swallow up to end tag since this is not valid
3482                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3483                     }
3484                 }
3485             }
3486             else
3487             {
3488                 if ( strict )
3489                 {
3490                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3491                 }
3492                 else
3493                 {
3494                     // swallow up to end tag since this is not valid
3495                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3496                 }
3497             }
3498         }
3499         return pluginContainer;
3500     } //-- PluginContainer parsePluginContainer( String, XmlPullParser, boolean ) 
3501 
3502     /**
3503      * Method parsePluginExecution.
3504      * 
3505      * @param tagName
3506      * @param strict
3507      * @param parser
3508      * @throws IOException
3509      * @throws XmlPullParserException
3510      * @return PluginExecution
3511      */
3512     private PluginExecution parsePluginExecution( String tagName, XmlPullParser parser, boolean strict )
3513         throws IOException, XmlPullParserException
3514     {
3515         PluginExecution pluginExecution = new PluginExecution();
3516         java.util.Set parsed = new java.util.HashSet();
3517         while ( parser.nextTag() == XmlPullParser.START_TAG )
3518         {
3519             if ( parser.getName().equals( "id" )  )
3520             {
3521                 if ( parsed.contains( "id" ) )
3522                 {
3523                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3524                 }
3525                 parsed.add( "id" );
3526                 pluginExecution.setId( getTrimmedValue( parser.nextText()) );
3527             }
3528             else if ( parser.getName().equals( "phase" )  )
3529             {
3530                 if ( parsed.contains( "phase" ) )
3531                 {
3532                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3533                 }
3534                 parsed.add( "phase" );
3535                 pluginExecution.setPhase( getTrimmedValue( parser.nextText()) );
3536             }
3537             else if ( parser.getName().equals( "goals" )  )
3538             {
3539                 if ( parsed.contains( "goals" ) )
3540                 {
3541                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3542                 }
3543                 parsed.add( "goals" );
3544                 java.util.List goals = new java.util.ArrayList();
3545                 pluginExecution.setGoals( goals );
3546                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3547                 {
3548                     if ( parser.getName().equals( "goal" ) )
3549                     {
3550                         goals.add( getTrimmedValue( parser.nextText()) );
3551                     }
3552                     else if ( strict )
3553                     {
3554                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3555                     }
3556                     else
3557                     {
3558                         // swallow up to end tag since this is not valid
3559                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3560                     }
3561                 }
3562             }
3563             else if ( parser.getName().equals( "inherited" )  )
3564             {
3565                 if ( parsed.contains( "inherited" ) )
3566                 {
3567                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3568                 }
3569                 parsed.add( "inherited" );
3570                 pluginExecution.setInherited( getTrimmedValue( parser.nextText()) );
3571             }
3572             else if ( parser.getName().equals( "configuration" )  )
3573             {
3574                 if ( parsed.contains( "configuration" ) )
3575                 {
3576                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3577                 }
3578                 parsed.add( "configuration" );
3579                 pluginExecution.setConfiguration( Xpp3DomBuilder.build( parser ) );
3580             }
3581             else
3582             {
3583                 if ( strict )
3584                 {
3585                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3586                 }
3587                 else
3588                 {
3589                     // swallow up to end tag since this is not valid
3590                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3591                 }
3592             }
3593         }
3594         return pluginExecution;
3595     } //-- PluginExecution parsePluginExecution( String, XmlPullParser, boolean ) 
3596 
3597     /**
3598      * Method parsePluginManagement.
3599      * 
3600      * @param tagName
3601      * @param strict
3602      * @param parser
3603      * @throws IOException
3604      * @throws XmlPullParserException
3605      * @return PluginManagement
3606      */
3607     private PluginManagement parsePluginManagement( String tagName, XmlPullParser parser, boolean strict )
3608         throws IOException, XmlPullParserException
3609     {
3610         PluginManagement pluginManagement = new PluginManagement();
3611         java.util.Set parsed = new java.util.HashSet();
3612         while ( parser.nextTag() == XmlPullParser.START_TAG )
3613         {
3614             if ( parser.getName().equals( "plugins" )  )
3615             {
3616                 if ( parsed.contains( "plugins" ) )
3617                 {
3618                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3619                 }
3620                 parsed.add( "plugins" );
3621                 java.util.List plugins = new java.util.ArrayList();
3622                 pluginManagement.setPlugins( plugins );
3623                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3624                 {
3625                     if ( parser.getName().equals( "plugin" ) )
3626                     {
3627                         plugins.add( parsePlugin( "plugin", parser, strict ) );
3628                     }
3629                     else if ( strict )
3630                     {
3631                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3632                     }
3633                     else
3634                     {
3635                         // swallow up to end tag since this is not valid
3636                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3637                     }
3638                 }
3639             }
3640             else
3641             {
3642                 if ( strict )
3643                 {
3644                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3645                 }
3646                 else
3647                 {
3648                     // swallow up to end tag since this is not valid
3649                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3650                 }
3651             }
3652         }
3653         return pluginManagement;
3654     } //-- PluginManagement parsePluginManagement( String, XmlPullParser, boolean ) 
3655 
3656     /**
3657      * Method parsePrerequisites.
3658      * 
3659      * @param tagName
3660      * @param strict
3661      * @param parser
3662      * @throws IOException
3663      * @throws XmlPullParserException
3664      * @return Prerequisites
3665      */
3666     private Prerequisites parsePrerequisites( String tagName, XmlPullParser parser, boolean strict )
3667         throws IOException, XmlPullParserException
3668     {
3669         Prerequisites prerequisites = new Prerequisites();
3670         java.util.Set parsed = new java.util.HashSet();
3671         while ( parser.nextTag() == XmlPullParser.START_TAG )
3672         {
3673             if ( parser.getName().equals( "maven" )  )
3674             {
3675                 if ( parsed.contains( "maven" ) )
3676                 {
3677                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3678                 }
3679                 parsed.add( "maven" );
3680                 prerequisites.setMaven( getTrimmedValue( parser.nextText()) );
3681             }
3682             else
3683             {
3684                 if ( strict )
3685                 {
3686                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3687                 }
3688                 else
3689                 {
3690                     // swallow up to end tag since this is not valid
3691                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3692                 }
3693             }
3694         }
3695         return prerequisites;
3696     } //-- Prerequisites parsePrerequisites( String, XmlPullParser, boolean ) 
3697 
3698     /**
3699      * Method parseProfile.
3700      * 
3701      * @param tagName
3702      * @param strict
3703      * @param parser
3704      * @throws IOException
3705      * @throws XmlPullParserException
3706      * @return Profile
3707      */
3708     private Profile parseProfile( String tagName, XmlPullParser parser, boolean strict )
3709         throws IOException, XmlPullParserException
3710     {
3711         Profile profile = new Profile();
3712         java.util.Set parsed = new java.util.HashSet();
3713         while ( parser.nextTag() == XmlPullParser.START_TAG )
3714         {
3715             if ( parser.getName().equals( "id" )  )
3716             {
3717                 if ( parsed.contains( "id" ) )
3718                 {
3719                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3720                 }
3721                 parsed.add( "id" );
3722                 profile.setId( getTrimmedValue( parser.nextText()) );
3723             }
3724             else if ( parser.getName().equals( "activation" )  )
3725             {
3726                 if ( parsed.contains( "activation" ) )
3727                 {
3728                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3729                 }
3730                 parsed.add( "activation" );
3731                 profile.setActivation( parseActivation( "activation", parser, strict ) );
3732             }
3733             else if ( parser.getName().equals( "build" )  )
3734             {
3735                 if ( parsed.contains( "build" ) )
3736                 {
3737                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3738                 }
3739                 parsed.add( "build" );
3740                 profile.setBuild( parseBuildBase( "build", parser, strict ) );
3741             }
3742             else if ( parser.getName().equals( "distributionManagement" )  )
3743             {
3744                 if ( parsed.contains( "distributionManagement" ) )
3745                 {
3746                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3747                 }
3748                 parsed.add( "distributionManagement" );
3749                 profile.setDistributionManagement( parseDistributionManagement( "distributionManagement", parser, strict ) );
3750             }
3751             else if ( parser.getName().equals( "modules" )  )
3752             {
3753                 if ( parsed.contains( "modules" ) )
3754                 {
3755                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3756                 }
3757                 parsed.add( "modules" );
3758                 java.util.List modules = new java.util.ArrayList();
3759                 profile.setModules( modules );
3760                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3761                 {
3762                     if ( parser.getName().equals( "module" ) )
3763                     {
3764                         modules.add( getTrimmedValue( parser.nextText()) );
3765                     }
3766                     else if ( strict )
3767                     {
3768                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3769                     }
3770                     else
3771                     {
3772                         // swallow up to end tag since this is not valid
3773                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3774                     }
3775                 }
3776             }
3777             else if ( parser.getName().equals( "repositories" )  )
3778             {
3779                 if ( parsed.contains( "repositories" ) )
3780                 {
3781                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3782                 }
3783                 parsed.add( "repositories" );
3784                 java.util.List repositories = new java.util.ArrayList();
3785                 profile.setRepositories( repositories );
3786                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3787                 {
3788                     if ( parser.getName().equals( "repository" ) )
3789                     {
3790                         repositories.add( parseRepository( "repository", parser, strict ) );
3791                     }
3792                     else if ( strict )
3793                     {
3794                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3795                     }
3796                     else
3797                     {
3798                         // swallow up to end tag since this is not valid
3799                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3800                     }
3801                 }
3802             }
3803             else if ( parser.getName().equals( "pluginRepositories" )  )
3804             {
3805                 if ( parsed.contains( "pluginRepositories" ) )
3806                 {
3807                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3808                 }
3809                 parsed.add( "pluginRepositories" );
3810                 java.util.List pluginRepositories = new java.util.ArrayList();
3811                 profile.setPluginRepositories( pluginRepositories );
3812                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3813                 {
3814                     if ( parser.getName().equals( "pluginRepository" ) )
3815                     {
3816                         pluginRepositories.add( parseRepository( "pluginRepository", parser, strict ) );
3817                     }
3818                     else if ( strict )
3819                     {
3820                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3821                     }
3822                     else
3823                     {
3824                         // swallow up to end tag since this is not valid
3825                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3826                     }
3827                 }
3828             }
3829             else if ( parser.getName().equals( "dependencies" )  )
3830             {
3831                 if ( parsed.contains( "dependencies" ) )
3832                 {
3833                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3834                 }
3835                 parsed.add( "dependencies" );
3836                 java.util.List dependencies = new java.util.ArrayList();
3837                 profile.setDependencies( dependencies );
3838                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3839                 {
3840                     if ( parser.getName().equals( "dependency" ) )
3841                     {
3842                         dependencies.add( parseDependency( "dependency", parser, strict ) );
3843                     }
3844                     else if ( strict )
3845                     {
3846                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
3847                     }
3848                     else
3849                     {
3850                         // swallow up to end tag since this is not valid
3851                         while ( parser.next() != XmlPullParser.END_TAG ) {}
3852                     }
3853                 }
3854             }
3855             else if ( parser.getName().equals( "reports" )  )
3856             {
3857                 if ( parsed.contains( "reports" ) )
3858                 {
3859                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3860                 }
3861                 parsed.add( "reports" );
3862                 profile.setReports( Xpp3DomBuilder.build( parser ) );
3863             }
3864             else if ( parser.getName().equals( "reporting" )  )
3865             {
3866                 if ( parsed.contains( "reporting" ) )
3867                 {
3868                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3869                 }
3870                 parsed.add( "reporting" );
3871                 profile.setReporting( parseReporting( "reporting", parser, strict ) );
3872             }
3873             else if ( parser.getName().equals( "dependencyManagement" )  )
3874             {
3875                 if ( parsed.contains( "dependencyManagement" ) )
3876                 {
3877                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3878                 }
3879                 parsed.add( "dependencyManagement" );
3880                 profile.setDependencyManagement( parseDependencyManagement( "dependencyManagement", parser, strict ) );
3881             }
3882             else if ( parser.getName().equals( "properties" )  )
3883             {
3884                 if ( parsed.contains( "properties" ) )
3885                 {
3886                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3887                 }
3888                 parsed.add( "properties" );
3889                 while ( parser.nextTag() == XmlPullParser.START_TAG )
3890                 {
3891                     String key = parser.getName();
3892                     String value = parser.nextText().trim();
3893                     profile.addProperty( key, value );
3894                 }
3895             }
3896             else
3897             {
3898                 if ( strict )
3899                 {
3900                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3901                 }
3902                 else
3903                 {
3904                     // swallow up to end tag since this is not valid
3905                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3906                 }
3907             }
3908         }
3909         return profile;
3910     } //-- Profile parseProfile( String, XmlPullParser, boolean ) 
3911 
3912     /**
3913      * Method parseRelocation.
3914      * 
3915      * @param tagName
3916      * @param strict
3917      * @param parser
3918      * @throws IOException
3919      * @throws XmlPullParserException
3920      * @return Relocation
3921      */
3922     private Relocation parseRelocation( String tagName, XmlPullParser parser, boolean strict )
3923         throws IOException, XmlPullParserException
3924     {
3925         Relocation relocation = new Relocation();
3926         java.util.Set parsed = new java.util.HashSet();
3927         while ( parser.nextTag() == XmlPullParser.START_TAG )
3928         {
3929             if ( parser.getName().equals( "groupId" )  )
3930             {
3931                 if ( parsed.contains( "groupId" ) )
3932                 {
3933                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3934                 }
3935                 parsed.add( "groupId" );
3936                 relocation.setGroupId( getTrimmedValue( parser.nextText()) );
3937             }
3938             else if ( parser.getName().equals( "artifactId" )  )
3939             {
3940                 if ( parsed.contains( "artifactId" ) )
3941                 {
3942                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3943                 }
3944                 parsed.add( "artifactId" );
3945                 relocation.setArtifactId( getTrimmedValue( parser.nextText()) );
3946             }
3947             else if ( parser.getName().equals( "version" )  )
3948             {
3949                 if ( parsed.contains( "version" ) )
3950                 {
3951                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3952                 }
3953                 parsed.add( "version" );
3954                 relocation.setVersion( getTrimmedValue( parser.nextText()) );
3955             }
3956             else if ( parser.getName().equals( "message" )  )
3957             {
3958                 if ( parsed.contains( "message" ) )
3959                 {
3960                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
3961                 }
3962                 parsed.add( "message" );
3963                 relocation.setMessage( getTrimmedValue( parser.nextText()) );
3964             }
3965             else
3966             {
3967                 if ( strict )
3968                 {
3969                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
3970                 }
3971                 else
3972                 {
3973                     // swallow up to end tag since this is not valid
3974                     while ( parser.next() != XmlPullParser.END_TAG ) {}
3975                 }
3976             }
3977         }
3978         return relocation;
3979     } //-- Relocation parseRelocation( String, XmlPullParser, boolean ) 
3980 
3981     /**
3982      * Method parseReportPlugin.
3983      * 
3984      * @param tagName
3985      * @param strict
3986      * @param parser
3987      * @throws IOException
3988      * @throws XmlPullParserException
3989      * @return ReportPlugin
3990      */
3991     private ReportPlugin parseReportPlugin( String tagName, XmlPullParser parser, boolean strict )
3992         throws IOException, XmlPullParserException
3993     {
3994         ReportPlugin reportPlugin = new ReportPlugin();
3995         java.util.Set parsed = new java.util.HashSet();
3996         while ( parser.nextTag() == XmlPullParser.START_TAG )
3997         {
3998             if ( parser.getName().equals( "groupId" )  )
3999             {
4000                 if ( parsed.contains( "groupId" ) )
4001                 {
4002                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4003                 }
4004                 parsed.add( "groupId" );
4005                 reportPlugin.setGroupId( getTrimmedValue( parser.nextText()) );
4006             }
4007             else if ( parser.getName().equals( "artifactId" )  )
4008             {
4009                 if ( parsed.contains( "artifactId" ) )
4010                 {
4011                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4012                 }
4013                 parsed.add( "artifactId" );
4014                 reportPlugin.setArtifactId( getTrimmedValue( parser.nextText()) );
4015             }
4016             else if ( parser.getName().equals( "version" )  )
4017             {
4018                 if ( parsed.contains( "version" ) )
4019                 {
4020                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4021                 }
4022                 parsed.add( "version" );
4023                 reportPlugin.setVersion( getTrimmedValue( parser.nextText()) );
4024             }
4025             else if ( parser.getName().equals( "inherited" )  )
4026             {
4027                 if ( parsed.contains( "inherited" ) )
4028                 {
4029                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4030                 }
4031                 parsed.add( "inherited" );
4032                 reportPlugin.setInherited( getTrimmedValue( parser.nextText()) );
4033             }
4034             else if ( parser.getName().equals( "configuration" )  )
4035             {
4036                 if ( parsed.contains( "configuration" ) )
4037                 {
4038                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4039                 }
4040                 parsed.add( "configuration" );
4041                 reportPlugin.setConfiguration( Xpp3DomBuilder.build( parser ) );
4042             }
4043             else if ( parser.getName().equals( "reportSets" )  )
4044             {
4045                 if ( parsed.contains( "reportSets" ) )
4046                 {
4047                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4048                 }
4049                 parsed.add( "reportSets" );
4050                 java.util.List reportSets = new java.util.ArrayList();
4051                 reportPlugin.setReportSets( reportSets );
4052                 while ( parser.nextTag() == XmlPullParser.START_TAG )
4053                 {
4054                     if ( parser.getName().equals( "reportSet" ) )
4055                     {
4056                         reportSets.add( parseReportSet( "reportSet", parser, strict ) );
4057                     }
4058                     else if ( strict )
4059                     {
4060                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
4061                     }
4062                     else
4063                     {
4064                         // swallow up to end tag since this is not valid
4065                         while ( parser.next() != XmlPullParser.END_TAG ) {}
4066                     }
4067                 }
4068             }
4069             else
4070             {
4071                 if ( strict )
4072                 {
4073                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4074                 }
4075                 else
4076                 {
4077                     // swallow up to end tag since this is not valid
4078                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4079                 }
4080             }
4081         }
4082         return reportPlugin;
4083     } //-- ReportPlugin parseReportPlugin( String, XmlPullParser, boolean ) 
4084 
4085     /**
4086      * Method parseReportSet.
4087      * 
4088      * @param tagName
4089      * @param strict
4090      * @param parser
4091      * @throws IOException
4092      * @throws XmlPullParserException
4093      * @return ReportSet
4094      */
4095     private ReportSet parseReportSet( String tagName, XmlPullParser parser, boolean strict )
4096         throws IOException, XmlPullParserException
4097     {
4098         ReportSet reportSet = new ReportSet();
4099         java.util.Set parsed = new java.util.HashSet();
4100         while ( parser.nextTag() == XmlPullParser.START_TAG )
4101         {
4102             if ( parser.getName().equals( "id" )  )
4103             {
4104                 if ( parsed.contains( "id" ) )
4105                 {
4106                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4107                 }
4108                 parsed.add( "id" );
4109                 reportSet.setId( getTrimmedValue( parser.nextText()) );
4110             }
4111             else if ( parser.getName().equals( "configuration" )  )
4112             {
4113                 if ( parsed.contains( "configuration" ) )
4114                 {
4115                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4116                 }
4117                 parsed.add( "configuration" );
4118                 reportSet.setConfiguration( Xpp3DomBuilder.build( parser ) );
4119             }
4120             else if ( parser.getName().equals( "inherited" )  )
4121             {
4122                 if ( parsed.contains( "inherited" ) )
4123                 {
4124                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4125                 }
4126                 parsed.add( "inherited" );
4127                 reportSet.setInherited( getTrimmedValue( parser.nextText()) );
4128             }
4129             else if ( parser.getName().equals( "reports" )  )
4130             {
4131                 if ( parsed.contains( "reports" ) )
4132                 {
4133                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4134                 }
4135                 parsed.add( "reports" );
4136                 java.util.List reports = new java.util.ArrayList();
4137                 reportSet.setReports( reports );
4138                 while ( parser.nextTag() == XmlPullParser.START_TAG )
4139                 {
4140                     if ( parser.getName().equals( "report" ) )
4141                     {
4142                         reports.add( getTrimmedValue( parser.nextText()) );
4143                     }
4144                     else if ( strict )
4145                     {
4146                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
4147                     }
4148                     else
4149                     {
4150                         // swallow up to end tag since this is not valid
4151                         while ( parser.next() != XmlPullParser.END_TAG ) {}
4152                     }
4153                 }
4154             }
4155             else
4156             {
4157                 if ( strict )
4158                 {
4159                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4160                 }
4161                 else
4162                 {
4163                     // swallow up to end tag since this is not valid
4164                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4165                 }
4166             }
4167         }
4168         return reportSet;
4169     } //-- ReportSet parseReportSet( String, XmlPullParser, boolean ) 
4170 
4171     /**
4172      * Method parseReporting.
4173      * 
4174      * @param tagName
4175      * @param strict
4176      * @param parser
4177      * @throws IOException
4178      * @throws XmlPullParserException
4179      * @return Reporting
4180      */
4181     private Reporting parseReporting( String tagName, XmlPullParser parser, boolean strict )
4182         throws IOException, XmlPullParserException
4183     {
4184         Reporting reporting = new Reporting();
4185         java.util.Set parsed = new java.util.HashSet();
4186         while ( parser.nextTag() == XmlPullParser.START_TAG )
4187         {
4188             if ( parser.getName().equals( "excludeDefaults" )  )
4189             {
4190                 if ( parsed.contains( "excludeDefaults" ) )
4191                 {
4192                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4193                 }
4194                 parsed.add( "excludeDefaults" );
4195                 reporting.setExcludeDefaultsValue( getTrimmedValue( parser.nextText()) );
4196             }
4197             else if ( parser.getName().equals( "outputDirectory" )  )
4198             {
4199                 if ( parsed.contains( "outputDirectory" ) )
4200                 {
4201                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4202                 }
4203                 parsed.add( "outputDirectory" );
4204                 reporting.setOutputDirectory( getTrimmedValue( parser.nextText()) );
4205             }
4206             else if ( parser.getName().equals( "plugins" )  )
4207             {
4208                 if ( parsed.contains( "plugins" ) )
4209                 {
4210                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4211                 }
4212                 parsed.add( "plugins" );
4213                 java.util.List plugins = new java.util.ArrayList();
4214                 reporting.setPlugins( plugins );
4215                 while ( parser.nextTag() == XmlPullParser.START_TAG )
4216                 {
4217                     if ( parser.getName().equals( "plugin" ) )
4218                     {
4219                         plugins.add( parseReportPlugin( "plugin", parser, strict ) );
4220                     }
4221                     else if ( strict )
4222                     {
4223                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
4224                     }
4225                     else
4226                     {
4227                         // swallow up to end tag since this is not valid
4228                         while ( parser.next() != XmlPullParser.END_TAG ) {}
4229                     }
4230                 }
4231             }
4232             else
4233             {
4234                 if ( strict )
4235                 {
4236                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4237                 }
4238                 else
4239                 {
4240                     // swallow up to end tag since this is not valid
4241                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4242                 }
4243             }
4244         }
4245         return reporting;
4246     } //-- Reporting parseReporting( String, XmlPullParser, boolean ) 
4247 
4248     /**
4249      * Method parseRepository.
4250      * 
4251      * @param tagName
4252      * @param strict
4253      * @param parser
4254      * @throws IOException
4255      * @throws XmlPullParserException
4256      * @return Repository
4257      */
4258     private Repository parseRepository( String tagName, XmlPullParser parser, boolean strict )
4259         throws IOException, XmlPullParserException
4260     {
4261         Repository repository = new Repository();
4262         java.util.Set parsed = new java.util.HashSet();
4263         while ( parser.nextTag() == XmlPullParser.START_TAG )
4264         {
4265             if ( parser.getName().equals( "releases" )  )
4266             {
4267                 if ( parsed.contains( "releases" ) )
4268                 {
4269                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4270                 }
4271                 parsed.add( "releases" );
4272                 repository.setReleases( parseRepositoryPolicy( "releases", parser, strict ) );
4273             }
4274             else if ( parser.getName().equals( "snapshots" )  )
4275             {
4276                 if ( parsed.contains( "snapshots" ) )
4277                 {
4278                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4279                 }
4280                 parsed.add( "snapshots" );
4281                 repository.setSnapshots( parseRepositoryPolicy( "snapshots", parser, strict ) );
4282             }
4283             else if ( parser.getName().equals( "id" )  )
4284             {
4285                 if ( parsed.contains( "id" ) )
4286                 {
4287                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4288                 }
4289                 parsed.add( "id" );
4290                 repository.setId( getTrimmedValue( parser.nextText()) );
4291             }
4292             else if ( parser.getName().equals( "name" )  )
4293             {
4294                 if ( parsed.contains( "name" ) )
4295                 {
4296                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4297                 }
4298                 parsed.add( "name" );
4299                 repository.setName( getTrimmedValue( parser.nextText()) );
4300             }
4301             else if ( parser.getName().equals( "url" )  )
4302             {
4303                 if ( parsed.contains( "url" ) )
4304                 {
4305                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4306                 }
4307                 parsed.add( "url" );
4308                 repository.setUrl( getTrimmedValue( parser.nextText()) );
4309             }
4310             else if ( parser.getName().equals( "layout" )  )
4311             {
4312                 if ( parsed.contains( "layout" ) )
4313                 {
4314                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4315                 }
4316                 parsed.add( "layout" );
4317                 repository.setLayout( getTrimmedValue( parser.nextText()) );
4318             }
4319             else
4320             {
4321                 if ( strict )
4322                 {
4323                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4324                 }
4325                 else
4326                 {
4327                     // swallow up to end tag since this is not valid
4328                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4329                 }
4330             }
4331         }
4332         return repository;
4333     } //-- Repository parseRepository( String, XmlPullParser, boolean ) 
4334 
4335     /**
4336      * Method parseRepositoryBase.
4337      * 
4338      * @param tagName
4339      * @param strict
4340      * @param parser
4341      * @throws IOException
4342      * @throws XmlPullParserException
4343      * @return RepositoryBase
4344      */
4345     private RepositoryBase parseRepositoryBase( String tagName, XmlPullParser parser, boolean strict )
4346         throws IOException, XmlPullParserException
4347     {
4348         RepositoryBase repositoryBase = new RepositoryBase();
4349         java.util.Set parsed = new java.util.HashSet();
4350         while ( parser.nextTag() == XmlPullParser.START_TAG )
4351         {
4352             if ( parser.getName().equals( "id" )  )
4353             {
4354                 if ( parsed.contains( "id" ) )
4355                 {
4356                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4357                 }
4358                 parsed.add( "id" );
4359                 repositoryBase.setId( getTrimmedValue( parser.nextText()) );
4360             }
4361             else if ( parser.getName().equals( "name" )  )
4362             {
4363                 if ( parsed.contains( "name" ) )
4364                 {
4365                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4366                 }
4367                 parsed.add( "name" );
4368                 repositoryBase.setName( getTrimmedValue( parser.nextText()) );
4369             }
4370             else if ( parser.getName().equals( "url" )  )
4371             {
4372                 if ( parsed.contains( "url" ) )
4373                 {
4374                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4375                 }
4376                 parsed.add( "url" );
4377                 repositoryBase.setUrl( getTrimmedValue( parser.nextText()) );
4378             }
4379             else if ( parser.getName().equals( "layout" )  )
4380             {
4381                 if ( parsed.contains( "layout" ) )
4382                 {
4383                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4384                 }
4385                 parsed.add( "layout" );
4386                 repositoryBase.setLayout( getTrimmedValue( parser.nextText()) );
4387             }
4388             else
4389             {
4390                 if ( strict )
4391                 {
4392                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4393                 }
4394                 else
4395                 {
4396                     // swallow up to end tag since this is not valid
4397                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4398                 }
4399             }
4400         }
4401         return repositoryBase;
4402     } //-- RepositoryBase parseRepositoryBase( String, XmlPullParser, boolean ) 
4403 
4404     /**
4405      * Method parseRepositoryPolicy.
4406      * 
4407      * @param tagName
4408      * @param strict
4409      * @param parser
4410      * @throws IOException
4411      * @throws XmlPullParserException
4412      * @return RepositoryPolicy
4413      */
4414     private RepositoryPolicy parseRepositoryPolicy( String tagName, XmlPullParser parser, boolean strict )
4415         throws IOException, XmlPullParserException
4416     {
4417         RepositoryPolicy repositoryPolicy = new RepositoryPolicy();
4418         java.util.Set parsed = new java.util.HashSet();
4419         while ( parser.nextTag() == XmlPullParser.START_TAG )
4420         {
4421             if ( parser.getName().equals( "enabled" )  )
4422             {
4423                 if ( parsed.contains( "enabled" ) )
4424                 {
4425                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4426                 }
4427                 parsed.add( "enabled" );
4428                 repositoryPolicy.setEnabled( getBooleanValue( getTrimmedValue( parser.nextText()), "enabled", parser, "true" ) );
4429             }
4430             else if ( parser.getName().equals( "updatePolicy" )  )
4431             {
4432                 if ( parsed.contains( "updatePolicy" ) )
4433                 {
4434                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4435                 }
4436                 parsed.add( "updatePolicy" );
4437                 repositoryPolicy.setUpdatePolicy( getTrimmedValue( parser.nextText()) );
4438             }
4439             else if ( parser.getName().equals( "checksumPolicy" )  )
4440             {
4441                 if ( parsed.contains( "checksumPolicy" ) )
4442                 {
4443                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4444                 }
4445                 parsed.add( "checksumPolicy" );
4446                 repositoryPolicy.setChecksumPolicy( getTrimmedValue( parser.nextText()) );
4447             }
4448             else
4449             {
4450                 if ( strict )
4451                 {
4452                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4453                 }
4454                 else
4455                 {
4456                     // swallow up to end tag since this is not valid
4457                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4458                 }
4459             }
4460         }
4461         return repositoryPolicy;
4462     } //-- RepositoryPolicy parseRepositoryPolicy( String, XmlPullParser, boolean ) 
4463 
4464     /**
4465      * Method parseResource.
4466      * 
4467      * @param tagName
4468      * @param strict
4469      * @param parser
4470      * @throws IOException
4471      * @throws XmlPullParserException
4472      * @return Resource
4473      */
4474     private Resource parseResource( String tagName, XmlPullParser parser, boolean strict )
4475         throws IOException, XmlPullParserException
4476     {
4477         Resource resource = new Resource();
4478         java.util.Set parsed = new java.util.HashSet();
4479         while ( parser.nextTag() == XmlPullParser.START_TAG )
4480         {
4481             if ( parser.getName().equals( "targetPath" )  )
4482             {
4483                 if ( parsed.contains( "targetPath" ) )
4484                 {
4485                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4486                 }
4487                 parsed.add( "targetPath" );
4488                 resource.setTargetPath( getTrimmedValue( parser.nextText()) );
4489             }
4490             else if ( parser.getName().equals( "filtering" )  )
4491             {
4492                 if ( parsed.contains( "filtering" ) )
4493                 {
4494                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4495                 }
4496                 parsed.add( "filtering" );
4497                 resource.setFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "filtering", parser, "false" ) );
4498             }
4499             else if ( parser.getName().equals( "mergeId" )  )
4500             {
4501                 if ( parsed.contains( "mergeId" ) )
4502                 {
4503                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4504                 }
4505                 parsed.add( "mergeId" );
4506                 resource.setMergeId( getTrimmedValue( parser.nextText()) );
4507             }
4508             else if ( parser.getName().equals( "directory" )  )
4509             {
4510                 if ( parsed.contains( "directory" ) )
4511                 {
4512                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4513                 }
4514                 parsed.add( "directory" );
4515                 resource.setDirectory( getTrimmedValue( parser.nextText()) );
4516             }
4517             else if ( parser.getName().equals( "includes" )  )
4518             {
4519                 if ( parsed.contains( "includes" ) )
4520                 {
4521                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4522                 }
4523                 parsed.add( "includes" );
4524                 java.util.List includes = new java.util.ArrayList();
4525                 resource.setIncludes( includes );
4526                 while ( parser.nextTag() == XmlPullParser.START_TAG )
4527                 {
4528                     if ( parser.getName().equals( "include" ) )
4529                     {
4530                         includes.add( getTrimmedValue( parser.nextText()) );
4531                     }
4532                     else if ( strict )
4533                     {
4534                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
4535                     }
4536                     else
4537                     {
4538                         // swallow up to end tag since this is not valid
4539                         while ( parser.next() != XmlPullParser.END_TAG ) {}
4540                     }
4541                 }
4542             }
4543             else if ( parser.getName().equals( "excludes" )  )
4544             {
4545                 if ( parsed.contains( "excludes" ) )
4546                 {
4547                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4548                 }
4549                 parsed.add( "excludes" );
4550                 java.util.List excludes = new java.util.ArrayList();
4551                 resource.setExcludes( excludes );
4552                 while ( parser.nextTag() == XmlPullParser.START_TAG )
4553                 {
4554                     if ( parser.getName().equals( "exclude" ) )
4555                     {
4556                         excludes.add( getTrimmedValue( parser.nextText()) );
4557                     }
4558                     else if ( strict )
4559                     {
4560                         throw new XmlPullParserException( "Unrecognised association: '" + parser.getName() + "'", parser, null );
4561                     }
4562                     else
4563                     {
4564                         // swallow up to end tag since this is not valid
4565                         while ( parser.next() != XmlPullParser.END_TAG ) {}
4566                     }
4567                 }
4568             }
4569             else
4570             {
4571                 if ( strict )
4572                 {
4573                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4574                 }
4575                 else
4576                 {
4577                     // swallow up to end tag since this is not valid
4578                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4579                 }
4580             }
4581         }
4582         return resource;
4583     } //-- Resource parseResource( String, XmlPullParser, boolean ) 
4584 
4585     /**
4586      * Method parseScm.
4587      * 
4588      * @param tagName
4589      * @param strict
4590      * @param parser
4591      * @throws IOException
4592      * @throws XmlPullParserException
4593      * @return Scm
4594      */
4595     private Scm parseScm( String tagName, XmlPullParser parser, boolean strict )
4596         throws IOException, XmlPullParserException
4597     {
4598         Scm scm = new Scm();
4599         java.util.Set parsed = new java.util.HashSet();
4600         while ( parser.nextTag() == XmlPullParser.START_TAG )
4601         {
4602             if ( parser.getName().equals( "connection" )  )
4603             {
4604                 if ( parsed.contains( "connection" ) )
4605                 {
4606                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4607                 }
4608                 parsed.add( "connection" );
4609                 scm.setConnection( getTrimmedValue( parser.nextText()) );
4610             }
4611             else if ( parser.getName().equals( "developerConnection" )  )
4612             {
4613                 if ( parsed.contains( "developerConnection" ) )
4614                 {
4615                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4616                 }
4617                 parsed.add( "developerConnection" );
4618                 scm.setDeveloperConnection( getTrimmedValue( parser.nextText()) );
4619             }
4620             else if ( parser.getName().equals( "tag" )  )
4621             {
4622                 if ( parsed.contains( "tag" ) )
4623                 {
4624                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4625                 }
4626                 parsed.add( "tag" );
4627                 scm.setTag( getTrimmedValue( parser.nextText()) );
4628             }
4629             else if ( parser.getName().equals( "url" )  )
4630             {
4631                 if ( parsed.contains( "url" ) )
4632                 {
4633                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4634                 }
4635                 parsed.add( "url" );
4636                 scm.setUrl( getTrimmedValue( parser.nextText()) );
4637             }
4638             else
4639             {
4640                 if ( strict )
4641                 {
4642                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4643                 }
4644                 else
4645                 {
4646                     // swallow up to end tag since this is not valid
4647                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4648                 }
4649             }
4650         }
4651         return scm;
4652     } //-- Scm parseScm( String, XmlPullParser, boolean ) 
4653 
4654     /**
4655      * Method parseSite.
4656      * 
4657      * @param tagName
4658      * @param strict
4659      * @param parser
4660      * @throws IOException
4661      * @throws XmlPullParserException
4662      * @return Site
4663      */
4664     private Site parseSite( String tagName, XmlPullParser parser, boolean strict )
4665         throws IOException, XmlPullParserException
4666     {
4667         Site site = new Site();
4668         java.util.Set parsed = new java.util.HashSet();
4669         while ( parser.nextTag() == XmlPullParser.START_TAG )
4670         {
4671             if ( parser.getName().equals( "id" )  )
4672             {
4673                 if ( parsed.contains( "id" ) )
4674                 {
4675                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4676                 }
4677                 parsed.add( "id" );
4678                 site.setId( getTrimmedValue( parser.nextText()) );
4679             }
4680             else if ( parser.getName().equals( "name" )  )
4681             {
4682                 if ( parsed.contains( "name" ) )
4683                 {
4684                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4685                 }
4686                 parsed.add( "name" );
4687                 site.setName( getTrimmedValue( parser.nextText()) );
4688             }
4689             else if ( parser.getName().equals( "url" )  )
4690             {
4691                 if ( parsed.contains( "url" ) )
4692                 {
4693                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null );
4694                 }
4695                 parsed.add( "url" );
4696                 site.setUrl( getTrimmedValue( parser.nextText()) );
4697             }
4698             else
4699             {
4700                 if ( strict )
4701                 {
4702                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
4703                 }
4704                 else
4705                 {
4706                     // swallow up to end tag since this is not valid
4707                     while ( parser.next() != XmlPullParser.END_TAG ) {}
4708                 }
4709             }
4710         }
4711         return site;
4712     } //-- Site parseSite( String, XmlPullParser, boolean ) 
4713 
4714     /**
4715      * @see ReaderFactory#newXmlReader
4716      * 
4717      * @param reader
4718      * @param strict
4719      * @throws IOException
4720      * @throws XmlPullParserException
4721      * @return Model
4722      */
4723     public Model read( Reader reader, boolean strict )
4724         throws IOException, XmlPullParserException
4725     {
4726         XmlPullParser parser = new MXParser();
4727     
4728         parser.setInput( reader );
4729     
4730         if ( addDefaultEntities )
4731         {
4732             // ----------------------------------------------------------------------
4733             // Latin 1 entities
4734             // ----------------------------------------------------------------------
4735     
4736             parser.defineEntityReplacementText( "nbsp", "\u00a0" );
4737             parser.defineEntityReplacementText( "iexcl", "\u00a1" );
4738             parser.defineEntityReplacementText( "cent", "\u00a2" );
4739             parser.defineEntityReplacementText( "pound", "\u00a3" );
4740             parser.defineEntityReplacementText( "curren", "\u00a4" );
4741             parser.defineEntityReplacementText( "yen", "\u00a5" );
4742             parser.defineEntityReplacementText( "brvbar", "\u00a6" );
4743             parser.defineEntityReplacementText( "sect", "\u00a7" );
4744             parser.defineEntityReplacementText( "uml", "\u00a8" );
4745             parser.defineEntityReplacementText( "copy", "\u00a9" );
4746             parser.defineEntityReplacementText( "ordf", "\u00aa" );
4747             parser.defineEntityReplacementText( "laquo", "\u00ab" );
4748             parser.defineEntityReplacementText( "not", "\u00ac" );
4749             parser.defineEntityReplacementText( "shy", "\u00ad" );
4750             parser.defineEntityReplacementText( "reg", "\u00ae" );
4751             parser.defineEntityReplacementText( "macr", "\u00af" );
4752             parser.defineEntityReplacementText( "deg", "\u00b0" );
4753             parser.defineEntityReplacementText( "plusmn", "\u00b1" );
4754             parser.defineEntityReplacementText( "sup2", "\u00b2" );
4755             parser.defineEntityReplacementText( "sup3", "\u00b3" );
4756             parser.defineEntityReplacementText( "acute", "\u00b4" );
4757             parser.defineEntityReplacementText( "micro", "\u00b5" );
4758             parser.defineEntityReplacementText( "para", "\u00b6" );
4759             parser.defineEntityReplacementText( "middot", "\u00b7" );
4760             parser.defineEntityReplacementText( "cedil", "\u00b8" );
4761             parser.defineEntityReplacementText( "sup1", "\u00b9" );
4762             parser.defineEntityReplacementText( "ordm", "\u00ba" );
4763             parser.defineEntityReplacementText( "raquo", "\u00bb" );
4764             parser.defineEntityReplacementText( "frac14", "\u00bc" );
4765             parser.defineEntityReplacementText( "frac12", "\u00bd" );
4766             parser.defineEntityReplacementText( "frac34", "\u00be" );
4767             parser.defineEntityReplacementText( "iquest", "\u00bf" );
4768             parser.defineEntityReplacementText( "Agrave", "\u00c0" );
4769             parser.defineEntityReplacementText( "Aacute", "\u00c1" );
4770             parser.defineEntityReplacementText( "Acirc", "\u00c2" );
4771             parser.defineEntityReplacementText( "Atilde", "\u00c3" );
4772             parser.defineEntityReplacementText( "Auml", "\u00c4" );
4773             parser.defineEntityReplacementText( "Aring", "\u00c5" );
4774             parser.defineEntityReplacementText( "AElig", "\u00c6" );
4775             parser.defineEntityReplacementText( "Ccedil", "\u00c7" );
4776             parser.defineEntityReplacementText( "Egrave", "\u00c8" );
4777             parser.defineEntityReplacementText( "Eacute", "\u00c9" );
4778             parser.defineEntityReplacementText( "Ecirc", "\u00ca" );
4779             parser.defineEntityReplacementText( "Euml", "\u00cb" );
4780             parser.defineEntityReplacementText( "Igrave", "\u00cc" );
4781             parser.defineEntityReplacementText( "Iacute", "\u00cd" );
4782             parser.defineEntityReplacementText( "Icirc", "\u00ce" );
4783             parser.defineEntityReplacementText( "Iuml", "\u00cf" );
4784             parser.defineEntityReplacementText( "ETH", "\u00d0" );
4785             parser.defineEntityReplacementText( "Ntilde", "\u00d1" );
4786             parser.defineEntityReplacementText( "Ograve", "\u00d2" );
4787             parser.defineEntityReplacementText( "Oacute", "\u00d3" );
4788             parser.defineEntityReplacementText( "Ocirc", "\u00d4" );
4789             parser.defineEntityReplacementText( "Otilde", "\u00d5" );
4790             parser.defineEntityReplacementText( "Ouml", "\u00d6" );
4791             parser.defineEntityReplacementText( "times", "\u00d7" );
4792             parser.defineEntityReplacementText( "Oslash", "\u00d8" );
4793             parser.defineEntityReplacementText( "Ugrave", "\u00d9" );
4794             parser.defineEntityReplacementText( "Uacute", "\u00da" );
4795             parser.defineEntityReplacementText( "Ucirc", "\u00db" );
4796             parser.defineEntityReplacementText( "Uuml", "\u00dc" );
4797             parser.defineEntityReplacementText( "Yacute", "\u00dd" );
4798             parser.defineEntityReplacementText( "THORN", "\u00de" );
4799             parser.defineEntityReplacementText( "szlig", "\u00df" );
4800             parser.defineEntityReplacementText( "agrave", "\u00e0" );
4801             parser.defineEntityReplacementText( "aacute", "\u00e1" );
4802             parser.defineEntityReplacementText( "acirc", "\u00e2" );
4803             parser.defineEntityReplacementText( "atilde", "\u00e3" );
4804             parser.defineEntityReplacementText( "auml", "\u00e4" );
4805             parser.defineEntityReplacementText( "aring", "\u00e5" );
4806             parser.defineEntityReplacementText( "aelig", "\u00e6" );
4807             parser.defineEntityReplacementText( "ccedil", "\u00e7" );
4808             parser.defineEntityReplacementText( "egrave", "\u00e8" );
4809             parser.defineEntityReplacementText( "eacute", "\u00e9" );
4810             parser.defineEntityReplacementText( "ecirc", "\u00ea" );
4811             parser.defineEntityReplacementText( "euml", "\u00eb" );
4812             parser.defineEntityReplacementText( "igrave", "\u00ec" );
4813             parser.defineEntityReplacementText( "iacute", "\u00ed" );
4814             parser.defineEntityReplacementText( "icirc", "\u00ee" );
4815             parser.defineEntityReplacementText( "iuml", "\u00ef" );
4816             parser.defineEntityReplacementText( "eth", "\u00f0" );
4817             parser.defineEntityReplacementText( "ntilde", "\u00f1" );
4818             parser.defineEntityReplacementText( "ograve", "\u00f2" );
4819             parser.defineEntityReplacementText( "oacute", "\u00f3" );
4820             parser.defineEntityReplacementText( "ocirc", "\u00f4" );
4821             parser.defineEntityReplacementText( "otilde", "\u00f5" );
4822             parser.defineEntityReplacementText( "ouml", "\u00f6" );
4823             parser.defineEntityReplacementText( "divide", "\u00f7" );
4824             parser.defineEntityReplacementText( "oslash", "\u00f8" );
4825             parser.defineEntityReplacementText( "ugrave", "\u00f9" );
4826             parser.defineEntityReplacementText( "uacute", "\u00fa" );
4827             parser.defineEntityReplacementText( "ucirc", "\u00fb" );
4828             parser.defineEntityReplacementText( "uuml", "\u00fc" );
4829             parser.defineEntityReplacementText( "yacute", "\u00fd" );
4830             parser.defineEntityReplacementText( "thorn", "\u00fe" );
4831             parser.defineEntityReplacementText( "yuml", "\u00ff" );
4832     
4833             // ----------------------------------------------------------------------
4834             // Special entities
4835             // ----------------------------------------------------------------------
4836     
4837             parser.defineEntityReplacementText( "OElig", "\u0152" );
4838             parser.defineEntityReplacementText( "oelig", "\u0153" );
4839             parser.defineEntityReplacementText( "Scaron", "\u0160" );
4840             parser.defineEntityReplacementText( "scaron", "\u0161" );
4841             parser.defineEntityReplacementText( "Yuml", "\u0178" );
4842             parser.defineEntityReplacementText( "circ", "\u02c6" );
4843             parser.defineEntityReplacementText( "tilde", "\u02dc" );
4844             parser.defineEntityReplacementText( "ensp", "\u2002" );
4845             parser.defineEntityReplacementText( "emsp", "\u2003" );
4846             parser.defineEntityReplacementText( "thinsp", "\u2009" );
4847             parser.defineEntityReplacementText( "zwnj", "\u200c" );
4848             parser.defineEntityReplacementText( "zwj", "\u200d" );
4849             parser.defineEntityReplacementText( "lrm", "\u200e" );
4850             parser.defineEntityReplacementText( "rlm", "\u200f" );
4851             parser.defineEntityReplacementText( "ndash", "\u2013" );
4852             parser.defineEntityReplacementText( "mdash", "\u2014" );
4853             parser.defineEntityReplacementText( "lsquo", "\u2018" );
4854             parser.defineEntityReplacementText( "rsquo", "\u2019" );
4855             parser.defineEntityReplacementText( "sbquo", "\u201a" );
4856             parser.defineEntityReplacementText( "ldquo", "\u201c" );
4857             parser.defineEntityReplacementText( "rdquo", "\u201d" );
4858             parser.defineEntityReplacementText( "bdquo", "\u201e" );
4859             parser.defineEntityReplacementText( "dagger", "\u2020" );
4860             parser.defineEntityReplacementText( "Dagger", "\u2021" );
4861             parser.defineEntityReplacementText( "permil", "\u2030" );
4862             parser.defineEntityReplacementText( "lsaquo", "\u2039" );
4863             parser.defineEntityReplacementText( "rsaquo", "\u203a" );
4864             parser.defineEntityReplacementText( "euro", "\u20ac" );
4865     
4866             // ----------------------------------------------------------------------
4867             // Symbol entities
4868             // ----------------------------------------------------------------------
4869     
4870             parser.defineEntityReplacementText( "fnof", "\u0192" );
4871             parser.defineEntityReplacementText( "Alpha", "\u0391" );
4872             parser.defineEntityReplacementText( "Beta", "\u0392" );
4873             parser.defineEntityReplacementText( "Gamma", "\u0393" );
4874             parser.defineEntityReplacementText( "Delta", "\u0394" );
4875             parser.defineEntityReplacementText( "Epsilon", "\u0395" );
4876             parser.defineEntityReplacementText( "Zeta", "\u0396" );
4877             parser.defineEntityReplacementText( "Eta", "\u0397" );
4878             parser.defineEntityReplacementText( "Theta", "\u0398" );
4879             parser.defineEntityReplacementText( "Iota", "\u0399" );
4880             parser.defineEntityReplacementText( "Kappa", "\u039a" );
4881             parser.defineEntityReplacementText( "Lambda", "\u039b" );
4882             parser.defineEntityReplacementText( "Mu", "\u039c" );
4883             parser.defineEntityReplacementText( "Nu", "\u039d" );
4884             parser.defineEntityReplacementText( "Xi", "\u039e" );
4885             parser.defineEntityReplacementText( "Omicron", "\u039f" );
4886             parser.defineEntityReplacementText( "Pi", "\u03a0" );
4887             parser.defineEntityReplacementText( "Rho", "\u03a1" );
4888             parser.defineEntityReplacementText( "Sigma", "\u03a3" );
4889             parser.defineEntityReplacementText( "Tau", "\u03a4" );
4890             parser.defineEntityReplacementText( "Upsilon", "\u03a5" );
4891             parser.defineEntityReplacementText( "Phi", "\u03a6" );
4892             parser.defineEntityReplacementText( "Chi", "\u03a7" );
4893             parser.defineEntityReplacementText( "Psi", "\u03a8" );
4894             parser.defineEntityReplacementText( "Omega", "\u03a9" );
4895             parser.defineEntityReplacementText( "alpha", "\u03b1" );
4896             parser.defineEntityReplacementText( "beta", "\u03b2" );
4897             parser.defineEntityReplacementText( "gamma", "\u03b3" );
4898             parser.defineEntityReplacementText( "delta", "\u03b4" );
4899             parser.defineEntityReplacementText( "epsilon", "\u03b5" );
4900             parser.defineEntityReplacementText( "zeta", "\u03b6" );
4901             parser.defineEntityReplacementText( "eta", "\u03b7" );
4902             parser.defineEntityReplacementText( "theta", "\u03b8" );
4903             parser.defineEntityReplacementText( "iota", "\u03b9" );
4904             parser.defineEntityReplacementText( "kappa", "\u03ba" );
4905             parser.defineEntityReplacementText( "lambda", "\u03bb" );
4906             parser.defineEntityReplacementText( "mu", "\u03bc" );
4907             parser.defineEntityReplacementText( "nu", "\u03bd" );
4908             parser.defineEntityReplacementText( "xi", "\u03be" );
4909             parser.defineEntityReplacementText( "omicron", "\u03bf" );
4910             parser.defineEntityReplacementText( "pi", "\u03c0" );
4911             parser.defineEntityReplacementText( "rho", "\u03c1" );
4912             parser.defineEntityReplacementText( "sigmaf", "\u03c2" );
4913             parser.defineEntityReplacementText( "sigma", "\u03c3" );
4914             parser.defineEntityReplacementText( "tau", "\u03c4" );
4915             parser.defineEntityReplacementText( "upsilon", "\u03c5" );
4916             parser.defineEntityReplacementText( "phi", "\u03c6" );
4917             parser.defineEntityReplacementText( "chi", "\u03c7" );
4918             parser.defineEntityReplacementText( "psi", "\u03c8" );
4919             parser.defineEntityReplacementText( "omega", "\u03c9" );
4920             parser.defineEntityReplacementText( "thetasym", "\u03d1" );
4921             parser.defineEntityReplacementText( "upsih", "\u03d2" );
4922             parser.defineEntityReplacementText( "piv", "\u03d6" );
4923             parser.defineEntityReplacementText( "bull", "\u2022" );
4924             parser.defineEntityReplacementText( "hellip", "\u2026" );
4925             parser.defineEntityReplacementText( "prime", "\u2032" );
4926             parser.defineEntityReplacementText( "Prime", "\u2033" );
4927             parser.defineEntityReplacementText( "oline", "\u203e" );
4928             parser.defineEntityReplacementText( "frasl", "\u2044" );
4929             parser.defineEntityReplacementText( "weierp", "\u2118" );
4930             parser.defineEntityReplacementText( "image", "\u2111" );
4931             parser.defineEntityReplacementText( "real", "\u211c" );
4932             parser.defineEntityReplacementText( "trade", "\u2122" );
4933             parser.defineEntityReplacementText( "alefsym", "\u2135" );
4934             parser.defineEntityReplacementText( "larr", "\u2190" );
4935             parser.defineEntityReplacementText( "uarr", "\u2191" );
4936             parser.defineEntityReplacementText( "rarr", "\u2192" );
4937             parser.defineEntityReplacementText( "darr", "\u2193" );
4938             parser.defineEntityReplacementText( "harr", "\u2194" );
4939             parser.defineEntityReplacementText( "crarr", "\u21b5" );
4940             parser.defineEntityReplacementText( "lArr", "\u21d0" );
4941             parser.defineEntityReplacementText( "uArr", "\u21d1" );
4942             parser.defineEntityReplacementText( "rArr", "\u21d2" );
4943             parser.defineEntityReplacementText( "dArr", "\u21d3" );
4944             parser.defineEntityReplacementText( "hArr", "\u21d4" );
4945             parser.defineEntityReplacementText( "forall", "\u2200" );
4946             parser.defineEntityReplacementText( "part", "\u2202" );
4947             parser.defineEntityReplacementText( "exist", "\u2203" );
4948             parser.defineEntityReplacementText( "empty", "\u2205" );
4949             parser.defineEntityReplacementText( "nabla", "\u2207" );
4950             parser.defineEntityReplacementText( "isin", "\u2208" );
4951             parser.defineEntityReplacementText( "notin", "\u2209" );
4952             parser.defineEntityReplacementText( "ni", "\u220b" );
4953             parser.defineEntityReplacementText( "prod", "\u220f" );
4954             parser.defineEntityReplacementText( "sum", "\u2211" );
4955             parser.defineEntityReplacementText( "minus", "\u2212" );
4956             parser.defineEntityReplacementText( "lowast", "\u2217" );
4957             parser.defineEntityReplacementText( "radic", "\u221a" );
4958             parser.defineEntityReplacementText( "prop", "\u221d" );
4959             parser.defineEntityReplacementText( "infin", "\u221e" );
4960             parser.defineEntityReplacementText( "ang", "\u2220" );
4961             parser.defineEntityReplacementText( "and", "\u2227" );
4962             parser.defineEntityReplacementText( "or", "\u2228" );
4963             parser.defineEntityReplacementText( "cap", "\u2229" );
4964             parser.defineEntityReplacementText( "cup", "\u222a" );
4965             parser.defineEntityReplacementText( "int", "\u222b" );
4966             parser.defineEntityReplacementText( "there4", "\u2234" );
4967             parser.defineEntityReplacementText( "sim", "\u223c" );
4968             parser.defineEntityReplacementText( "cong", "\u2245" );
4969             parser.defineEntityReplacementText( "asymp", "\u2248" );
4970             parser.defineEntityReplacementText( "ne", "\u2260" );
4971             parser.defineEntityReplacementText( "equiv", "\u2261" );
4972             parser.defineEntityReplacementText( "le", "\u2264" );
4973             parser.defineEntityReplacementText( "ge", "\u2265" );
4974             parser.defineEntityReplacementText( "sub", "\u2282" );
4975             parser.defineEntityReplacementText( "sup", "\u2283" );
4976             parser.defineEntityReplacementText( "nsub", "\u2284" );
4977             parser.defineEntityReplacementText( "sube", "\u2286" );
4978             parser.defineEntityReplacementText( "supe", "\u2287" );
4979             parser.defineEntityReplacementText( "oplus", "\u2295" );
4980             parser.defineEntityReplacementText( "otimes", "\u2297" );
4981             parser.defineEntityReplacementText( "perp", "\u22a5" );
4982             parser.defineEntityReplacementText( "sdot", "\u22c5" );
4983             parser.defineEntityReplacementText( "lceil", "\u2308" );
4984             parser.defineEntityReplacementText( "rceil", "\u2309" );
4985             parser.defineEntityReplacementText( "lfloor", "\u230a" );
4986             parser.defineEntityReplacementText( "rfloor", "\u230b" );
4987             parser.defineEntityReplacementText( "lang", "\u2329" );
4988             parser.defineEntityReplacementText( "rang", "\u232a" );
4989             parser.defineEntityReplacementText( "loz", "\u25ca" );
4990             parser.defineEntityReplacementText( "spades", "\u2660" );
4991             parser.defineEntityReplacementText( "clubs", "\u2663" );
4992             parser.defineEntityReplacementText( "hearts", "\u2665" );
4993             parser.defineEntityReplacementText( "diams", "\u2666" );
4994     
4995         }
4996     
4997         parser.next();
4998         return parseModel( "project", parser, strict );
4999     } //-- Model read( Reader, boolean ) 
5000 
5001     /**
5002      * @see ReaderFactory#newXmlReader
5003      * 
5004      * @param reader
5005      * @throws IOException
5006      * @throws XmlPullParserException
5007      * @return Model
5008      */
5009     public Model read( Reader reader )
5010         throws IOException, XmlPullParserException
5011     {
5012         return read( reader, true );
5013     } //-- Model read( Reader ) 
5014 
5015     /**
5016      * Method read.
5017      * 
5018      * @param in
5019      * @param strict
5020      * @throws IOException
5021      * @throws XmlPullParserException
5022      * @return Model
5023      */
5024     public Model read( InputStream in, boolean strict )
5025         throws IOException, XmlPullParserException
5026     {
5027         Reader reader = ReaderFactory.newXmlReader( in );
5028     
5029         return read( reader, strict );
5030     } //-- Model read( InputStream, boolean ) 
5031 
5032     /**
5033      * Method read.
5034      * 
5035      * @param in
5036      * @throws IOException
5037      * @throws XmlPullParserException
5038      * @return Model
5039      */
5040     public Model read( InputStream in )
5041         throws IOException, XmlPullParserException
5042     {
5043         Reader reader = ReaderFactory.newXmlReader( in );
5044     
5045         return read( reader );
5046     } //-- Model read( InputStream ) 
5047 
5048     /**
5049      * Sets the state of the "add default entities" flag.
5050      * 
5051      * @param addDefaultEntities
5052      */
5053     public void setAddDefaultEntities( boolean addDefaultEntities )
5054     {
5055         this.addDefaultEntities = addDefaultEntities;
5056     } //-- void setAddDefaultEntities( boolean ) 
5057 
5058 
5059 }