View Javadoc

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