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