View Javadoc

1   /*
2    =================== DO NOT EDIT THIS FILE ====================
3    Generated by Modello 1.4.1 on 2011-11-29 12:00:52,
4    any modifications will be overwritten.
5    ==============================================================
6    */
7   
8   package org.apache.maven.plugin.assembly.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.plugin.assembly.model.Component;
20  import org.apache.maven.plugin.assembly.model.ContainerDescriptorHandlerConfig;
21  import org.apache.maven.plugin.assembly.model.DependencySet;
22  import org.apache.maven.plugin.assembly.model.FileItem;
23  import org.apache.maven.plugin.assembly.model.FileSet;
24  import org.apache.maven.plugin.assembly.model.GroupVersionAlignment;
25  import org.apache.maven.plugin.assembly.model.ModuleBinaries;
26  import org.apache.maven.plugin.assembly.model.ModuleSet;
27  import org.apache.maven.plugin.assembly.model.ModuleSources;
28  import org.apache.maven.plugin.assembly.model.Repository;
29  import org.apache.maven.plugin.assembly.model.UnpackOptions;
30  import org.codehaus.plexus.util.ReaderFactory;
31  import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
32  import org.codehaus.plexus.util.xml.pull.MXParser;
33  import org.codehaus.plexus.util.xml.pull.XmlPullParser;
34  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
35  
36  /**
37   * Class ComponentXpp3Reader.
38   * 
39   * @version $Revision$ $Date$
40   */
41  @SuppressWarnings( "all" )
42  public class ComponentXpp3Reader
43  {
44  
45        //--------------------------/
46       //- Class/Member Variables -/
47      //--------------------------/
48  
49      /**
50       * If set the parser will be loaded with all single characters
51       * from the XHTML specification.
52       * The entities used:
53       * <ul>
54       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
55       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
56       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
57       * </ul>
58       */
59      private boolean addDefaultEntities = true;
60  
61  
62        //-----------/
63       //- Methods -/
64      //-----------/
65  
66      /**
67       * Method checkFieldWithDuplicate.
68       * 
69       * @param parser
70       * @param parsed
71       * @param alias
72       * @param tagName
73       * @throws XmlPullParserException
74       * @return boolean
75       */
76      private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set parsed )
77          throws XmlPullParserException
78      {
79          if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
80          {
81              return false;
82          }
83          if ( !parsed.add( tagName ) )
84          {
85              throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
86          }
87          return true;
88      } //-- boolean checkFieldWithDuplicate( XmlPullParser, String, String, java.util.Set )
89  
90      /**
91       * Method checkUnknownAttribute.
92       * 
93       * @param parser
94       * @param strict
95       * @param tagName
96       * @param attribute
97       * @throws XmlPullParserException
98       * @throws IOException
99       */
100     private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
101         throws XmlPullParserException, IOException
102     {
103         // strictXmlAttributes = true for model: if strict == true, not only elements are checked but attributes too
104         if ( strict )
105         {
106             throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
107         }
108     } //-- void checkUnknownAttribute( XmlPullParser, String, String, boolean )
109 
110     /**
111      * Method checkUnknownElement.
112      * 
113      * @param parser
114      * @param strict
115      * @throws XmlPullParserException
116      * @throws IOException
117      */
118     private void checkUnknownElement( XmlPullParser parser, boolean strict )
119         throws XmlPullParserException, IOException
120     {
121         if ( strict )
122         {
123             throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
124         }
125 
126         for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
127         {
128             int eventType = parser.next();
129             if ( eventType == XmlPullParser.START_TAG )
130             {
131                 unrecognizedTagCount++;
132             }
133             else if ( eventType == XmlPullParser.END_TAG )
134             {
135                 unrecognizedTagCount--;
136             }
137         }
138     } //-- void checkUnknownElement( XmlPullParser, boolean )
139 
140     /**
141      * Returns the state of the "add default entities" flag.
142      * 
143      * @return boolean
144      */
145     public boolean getAddDefaultEntities()
146     {
147         return addDefaultEntities;
148     } //-- boolean getAddDefaultEntities()
149 
150     /**
151      * Method getBooleanValue.
152      * 
153      * @param s
154      * @param parser
155      * @param attribute
156      * @throws XmlPullParserException
157      * @return boolean
158      */
159     private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
160         throws XmlPullParserException
161     {
162         return getBooleanValue( s, attribute, parser, null );
163     } //-- boolean getBooleanValue( String, String, XmlPullParser )
164 
165     /**
166      * Method getBooleanValue.
167      * 
168      * @param s
169      * @param defaultValue
170      * @param parser
171      * @param attribute
172      * @throws XmlPullParserException
173      * @return boolean
174      */
175     private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
176         throws XmlPullParserException
177     {
178         if ( s != null && s.length() != 0 )
179         {
180             return Boolean.valueOf( s ).booleanValue();
181         }
182         if ( defaultValue != null )
183         {
184             return Boolean.valueOf( defaultValue ).booleanValue();
185         }
186         return false;
187     } //-- boolean getBooleanValue( String, String, XmlPullParser, String )
188 
189     /**
190      * Method getByteValue.
191      * 
192      * @param s
193      * @param strict
194      * @param parser
195      * @param attribute
196      * @throws XmlPullParserException
197      * @return byte
198      */
199     private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
200         throws XmlPullParserException
201     {
202         if ( s != null )
203         {
204             try
205             {
206                 return Byte.valueOf( s ).byteValue();
207             }
208             catch ( NumberFormatException nfe )
209             {
210                 if ( strict )
211                 {
212                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
213                 }
214             }
215         }
216         return 0;
217     } //-- byte getByteValue( String, String, XmlPullParser, boolean )
218 
219     /**
220      * Method getCharacterValue.
221      * 
222      * @param s
223      * @param parser
224      * @param attribute
225      * @throws XmlPullParserException
226      * @return char
227      */
228     private char getCharacterValue( String s, String attribute, XmlPullParser parser )
229         throws XmlPullParserException
230     {
231         if ( s != null )
232         {
233             return s.charAt( 0 );
234         }
235         return 0;
236     } //-- char getCharacterValue( String, String, XmlPullParser )
237 
238     /**
239      * Method getDateValue.
240      * 
241      * @param s
242      * @param parser
243      * @param attribute
244      * @throws XmlPullParserException
245      * @return Date
246      */
247     private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
248         throws XmlPullParserException
249     {
250         return getDateValue( s, attribute, null, parser );
251     } //-- java.util.Date getDateValue( String, String, XmlPullParser )
252 
253     /**
254      * Method getDateValue.
255      * 
256      * @param s
257      * @param parser
258      * @param dateFormat
259      * @param attribute
260      * @throws XmlPullParserException
261      * @return Date
262      */
263     private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
264         throws XmlPullParserException
265     {
266         if ( s != null )
267         {
268             String effectiveDateFormat = dateFormat;
269             if ( dateFormat == null )
270             {
271                 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
272             }
273             if ( "long".equals( effectiveDateFormat ) )
274             {
275                 try
276                 {
277                     return new java.util.Date( Long.parseLong( s ) );
278                 }
279                 catch ( NumberFormatException e )
280                 {
281                     throw new XmlPullParserException( e.getMessage(), parser, e );
282                 }
283             }
284             else
285             {
286                 try
287                 {
288                     DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, Locale.US );
289                     return dateParser.parse( s );
290                 }
291                 catch ( java.text.ParseException e )
292                 {
293                     throw new XmlPullParserException( e.getMessage(), parser, e );
294                 }
295             }
296         }
297         return null;
298     } //-- java.util.Date getDateValue( String, String, String, XmlPullParser )
299 
300     /**
301      * Method getDoubleValue.
302      * 
303      * @param s
304      * @param strict
305      * @param parser
306      * @param attribute
307      * @throws XmlPullParserException
308      * @return double
309      */
310     private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
311         throws XmlPullParserException
312     {
313         if ( s != null )
314         {
315             try
316             {
317                 return Double.valueOf( s ).doubleValue();
318             }
319             catch ( NumberFormatException nfe )
320             {
321                 if ( strict )
322                 {
323                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
324                 }
325             }
326         }
327         return 0;
328     } //-- double getDoubleValue( String, String, XmlPullParser, boolean )
329 
330     /**
331      * Method getFloatValue.
332      * 
333      * @param s
334      * @param strict
335      * @param parser
336      * @param attribute
337      * @throws XmlPullParserException
338      * @return float
339      */
340     private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
341         throws XmlPullParserException
342     {
343         if ( s != null )
344         {
345             try
346             {
347                 return Float.valueOf( s ).floatValue();
348             }
349             catch ( NumberFormatException nfe )
350             {
351                 if ( strict )
352                 {
353                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
354                 }
355             }
356         }
357         return 0;
358     } //-- float getFloatValue( String, String, XmlPullParser, boolean )
359 
360     /**
361      * Method getIntegerValue.
362      * 
363      * @param s
364      * @param strict
365      * @param parser
366      * @param attribute
367      * @throws XmlPullParserException
368      * @return int
369      */
370     private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
371         throws XmlPullParserException
372     {
373         if ( s != null )
374         {
375             try
376             {
377                 return Integer.valueOf( s ).intValue();
378             }
379             catch ( NumberFormatException nfe )
380             {
381                 if ( strict )
382                 {
383                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
384                 }
385             }
386         }
387         return 0;
388     } //-- int getIntegerValue( String, String, XmlPullParser, boolean )
389 
390     /**
391      * Method getLongValue.
392      * 
393      * @param s
394      * @param strict
395      * @param parser
396      * @param attribute
397      * @throws XmlPullParserException
398      * @return long
399      */
400     private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
401         throws XmlPullParserException
402     {
403         if ( s != null )
404         {
405             try
406             {
407                 return Long.valueOf( s ).longValue();
408             }
409             catch ( NumberFormatException nfe )
410             {
411                 if ( strict )
412                 {
413                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
414                 }
415             }
416         }
417         return 0;
418     } //-- long getLongValue( String, String, XmlPullParser, boolean )
419 
420     /**
421      * Method getRequiredAttributeValue.
422      * 
423      * @param s
424      * @param strict
425      * @param parser
426      * @param attribute
427      * @throws XmlPullParserException
428      * @return String
429      */
430     private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
431         throws XmlPullParserException
432     {
433         if ( s == null )
434         {
435             if ( strict )
436             {
437                 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
438             }
439         }
440         return s;
441     } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean )
442 
443     /**
444      * Method getShortValue.
445      * 
446      * @param s
447      * @param strict
448      * @param parser
449      * @param attribute
450      * @throws XmlPullParserException
451      * @return short
452      */
453     private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
454         throws XmlPullParserException
455     {
456         if ( s != null )
457         {
458             try
459             {
460                 return Short.valueOf( s ).shortValue();
461             }
462             catch ( NumberFormatException nfe )
463             {
464                 if ( strict )
465                 {
466                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
467                 }
468             }
469         }
470         return 0;
471     } //-- short getShortValue( String, String, XmlPullParser, boolean )
472 
473     /**
474      * Method getTrimmedValue.
475      * 
476      * @param s
477      * @return String
478      */
479     private String getTrimmedValue( String s )
480     {
481         if ( s != null )
482         {
483             s = s.trim();
484         }
485         return s;
486     } //-- String getTrimmedValue( String )
487 
488     /**
489      * Method initParser.
490      * 
491      * @param parser
492      * @throws XmlPullParserException
493      */
494     private void initParser( XmlPullParser parser )
495         throws XmlPullParserException
496     {
497         if ( addDefaultEntities )
498         {
499             // ----------------------------------------------------------------------
500             // Latin 1 entities
501             // ----------------------------------------------------------------------
502 
503             parser.defineEntityReplacementText( "nbsp", "\u00a0" );
504             parser.defineEntityReplacementText( "iexcl", "\u00a1" );
505             parser.defineEntityReplacementText( "cent", "\u00a2" );
506             parser.defineEntityReplacementText( "pound", "\u00a3" );
507             parser.defineEntityReplacementText( "curren", "\u00a4" );
508             parser.defineEntityReplacementText( "yen", "\u00a5" );
509             parser.defineEntityReplacementText( "brvbar", "\u00a6" );
510             parser.defineEntityReplacementText( "sect", "\u00a7" );
511             parser.defineEntityReplacementText( "uml", "\u00a8" );
512             parser.defineEntityReplacementText( "copy", "\u00a9" );
513             parser.defineEntityReplacementText( "ordf", "\u00aa" );
514             parser.defineEntityReplacementText( "laquo", "\u00ab" );
515             parser.defineEntityReplacementText( "not", "\u00ac" );
516             parser.defineEntityReplacementText( "shy", "\u00ad" );
517             parser.defineEntityReplacementText( "reg", "\u00ae" );
518             parser.defineEntityReplacementText( "macr", "\u00af" );
519             parser.defineEntityReplacementText( "deg", "\u00b0" );
520             parser.defineEntityReplacementText( "plusmn", "\u00b1" );
521             parser.defineEntityReplacementText( "sup2", "\u00b2" );
522             parser.defineEntityReplacementText( "sup3", "\u00b3" );
523             parser.defineEntityReplacementText( "acute", "\u00b4" );
524             parser.defineEntityReplacementText( "micro", "\u00b5" );
525             parser.defineEntityReplacementText( "para", "\u00b6" );
526             parser.defineEntityReplacementText( "middot", "\u00b7" );
527             parser.defineEntityReplacementText( "cedil", "\u00b8" );
528             parser.defineEntityReplacementText( "sup1", "\u00b9" );
529             parser.defineEntityReplacementText( "ordm", "\u00ba" );
530             parser.defineEntityReplacementText( "raquo", "\u00bb" );
531             parser.defineEntityReplacementText( "frac14", "\u00bc" );
532             parser.defineEntityReplacementText( "frac12", "\u00bd" );
533             parser.defineEntityReplacementText( "frac34", "\u00be" );
534             parser.defineEntityReplacementText( "iquest", "\u00bf" );
535             parser.defineEntityReplacementText( "Agrave", "\u00c0" );
536             parser.defineEntityReplacementText( "Aacute", "\u00c1" );
537             parser.defineEntityReplacementText( "Acirc", "\u00c2" );
538             parser.defineEntityReplacementText( "Atilde", "\u00c3" );
539             parser.defineEntityReplacementText( "Auml", "\u00c4" );
540             parser.defineEntityReplacementText( "Aring", "\u00c5" );
541             parser.defineEntityReplacementText( "AElig", "\u00c6" );
542             parser.defineEntityReplacementText( "Ccedil", "\u00c7" );
543             parser.defineEntityReplacementText( "Egrave", "\u00c8" );
544             parser.defineEntityReplacementText( "Eacute", "\u00c9" );
545             parser.defineEntityReplacementText( "Ecirc", "\u00ca" );
546             parser.defineEntityReplacementText( "Euml", "\u00cb" );
547             parser.defineEntityReplacementText( "Igrave", "\u00cc" );
548             parser.defineEntityReplacementText( "Iacute", "\u00cd" );
549             parser.defineEntityReplacementText( "Icirc", "\u00ce" );
550             parser.defineEntityReplacementText( "Iuml", "\u00cf" );
551             parser.defineEntityReplacementText( "ETH", "\u00d0" );
552             parser.defineEntityReplacementText( "Ntilde", "\u00d1" );
553             parser.defineEntityReplacementText( "Ograve", "\u00d2" );
554             parser.defineEntityReplacementText( "Oacute", "\u00d3" );
555             parser.defineEntityReplacementText( "Ocirc", "\u00d4" );
556             parser.defineEntityReplacementText( "Otilde", "\u00d5" );
557             parser.defineEntityReplacementText( "Ouml", "\u00d6" );
558             parser.defineEntityReplacementText( "times", "\u00d7" );
559             parser.defineEntityReplacementText( "Oslash", "\u00d8" );
560             parser.defineEntityReplacementText( "Ugrave", "\u00d9" );
561             parser.defineEntityReplacementText( "Uacute", "\u00da" );
562             parser.defineEntityReplacementText( "Ucirc", "\u00db" );
563             parser.defineEntityReplacementText( "Uuml", "\u00dc" );
564             parser.defineEntityReplacementText( "Yacute", "\u00dd" );
565             parser.defineEntityReplacementText( "THORN", "\u00de" );
566             parser.defineEntityReplacementText( "szlig", "\u00df" );
567             parser.defineEntityReplacementText( "agrave", "\u00e0" );
568             parser.defineEntityReplacementText( "aacute", "\u00e1" );
569             parser.defineEntityReplacementText( "acirc", "\u00e2" );
570             parser.defineEntityReplacementText( "atilde", "\u00e3" );
571             parser.defineEntityReplacementText( "auml", "\u00e4" );
572             parser.defineEntityReplacementText( "aring", "\u00e5" );
573             parser.defineEntityReplacementText( "aelig", "\u00e6" );
574             parser.defineEntityReplacementText( "ccedil", "\u00e7" );
575             parser.defineEntityReplacementText( "egrave", "\u00e8" );
576             parser.defineEntityReplacementText( "eacute", "\u00e9" );
577             parser.defineEntityReplacementText( "ecirc", "\u00ea" );
578             parser.defineEntityReplacementText( "euml", "\u00eb" );
579             parser.defineEntityReplacementText( "igrave", "\u00ec" );
580             parser.defineEntityReplacementText( "iacute", "\u00ed" );
581             parser.defineEntityReplacementText( "icirc", "\u00ee" );
582             parser.defineEntityReplacementText( "iuml", "\u00ef" );
583             parser.defineEntityReplacementText( "eth", "\u00f0" );
584             parser.defineEntityReplacementText( "ntilde", "\u00f1" );
585             parser.defineEntityReplacementText( "ograve", "\u00f2" );
586             parser.defineEntityReplacementText( "oacute", "\u00f3" );
587             parser.defineEntityReplacementText( "ocirc", "\u00f4" );
588             parser.defineEntityReplacementText( "otilde", "\u00f5" );
589             parser.defineEntityReplacementText( "ouml", "\u00f6" );
590             parser.defineEntityReplacementText( "divide", "\u00f7" );
591             parser.defineEntityReplacementText( "oslash", "\u00f8" );
592             parser.defineEntityReplacementText( "ugrave", "\u00f9" );
593             parser.defineEntityReplacementText( "uacute", "\u00fa" );
594             parser.defineEntityReplacementText( "ucirc", "\u00fb" );
595             parser.defineEntityReplacementText( "uuml", "\u00fc" );
596             parser.defineEntityReplacementText( "yacute", "\u00fd" );
597             parser.defineEntityReplacementText( "thorn", "\u00fe" );
598             parser.defineEntityReplacementText( "yuml", "\u00ff" );
599 
600             // ----------------------------------------------------------------------
601             // Special entities
602             // ----------------------------------------------------------------------
603 
604             parser.defineEntityReplacementText( "OElig", "\u0152" );
605             parser.defineEntityReplacementText( "oelig", "\u0153" );
606             parser.defineEntityReplacementText( "Scaron", "\u0160" );
607             parser.defineEntityReplacementText( "scaron", "\u0161" );
608             parser.defineEntityReplacementText( "Yuml", "\u0178" );
609             parser.defineEntityReplacementText( "circ", "\u02c6" );
610             parser.defineEntityReplacementText( "tilde", "\u02dc" );
611             parser.defineEntityReplacementText( "ensp", "\u2002" );
612             parser.defineEntityReplacementText( "emsp", "\u2003" );
613             parser.defineEntityReplacementText( "thinsp", "\u2009" );
614             parser.defineEntityReplacementText( "zwnj", "\u200c" );
615             parser.defineEntityReplacementText( "zwj", "\u200d" );
616             parser.defineEntityReplacementText( "lrm", "\u200e" );
617             parser.defineEntityReplacementText( "rlm", "\u200f" );
618             parser.defineEntityReplacementText( "ndash", "\u2013" );
619             parser.defineEntityReplacementText( "mdash", "\u2014" );
620             parser.defineEntityReplacementText( "lsquo", "\u2018" );
621             parser.defineEntityReplacementText( "rsquo", "\u2019" );
622             parser.defineEntityReplacementText( "sbquo", "\u201a" );
623             parser.defineEntityReplacementText( "ldquo", "\u201c" );
624             parser.defineEntityReplacementText( "rdquo", "\u201d" );
625             parser.defineEntityReplacementText( "bdquo", "\u201e" );
626             parser.defineEntityReplacementText( "dagger", "\u2020" );
627             parser.defineEntityReplacementText( "Dagger", "\u2021" );
628             parser.defineEntityReplacementText( "permil", "\u2030" );
629             parser.defineEntityReplacementText( "lsaquo", "\u2039" );
630             parser.defineEntityReplacementText( "rsaquo", "\u203a" );
631             parser.defineEntityReplacementText( "euro", "\u20ac" );
632 
633             // ----------------------------------------------------------------------
634             // Symbol entities
635             // ----------------------------------------------------------------------
636 
637             parser.defineEntityReplacementText( "fnof", "\u0192" );
638             parser.defineEntityReplacementText( "Alpha", "\u0391" );
639             parser.defineEntityReplacementText( "Beta", "\u0392" );
640             parser.defineEntityReplacementText( "Gamma", "\u0393" );
641             parser.defineEntityReplacementText( "Delta", "\u0394" );
642             parser.defineEntityReplacementText( "Epsilon", "\u0395" );
643             parser.defineEntityReplacementText( "Zeta", "\u0396" );
644             parser.defineEntityReplacementText( "Eta", "\u0397" );
645             parser.defineEntityReplacementText( "Theta", "\u0398" );
646             parser.defineEntityReplacementText( "Iota", "\u0399" );
647             parser.defineEntityReplacementText( "Kappa", "\u039a" );
648             parser.defineEntityReplacementText( "Lambda", "\u039b" );
649             parser.defineEntityReplacementText( "Mu", "\u039c" );
650             parser.defineEntityReplacementText( "Nu", "\u039d" );
651             parser.defineEntityReplacementText( "Xi", "\u039e" );
652             parser.defineEntityReplacementText( "Omicron", "\u039f" );
653             parser.defineEntityReplacementText( "Pi", "\u03a0" );
654             parser.defineEntityReplacementText( "Rho", "\u03a1" );
655             parser.defineEntityReplacementText( "Sigma", "\u03a3" );
656             parser.defineEntityReplacementText( "Tau", "\u03a4" );
657             parser.defineEntityReplacementText( "Upsilon", "\u03a5" );
658             parser.defineEntityReplacementText( "Phi", "\u03a6" );
659             parser.defineEntityReplacementText( "Chi", "\u03a7" );
660             parser.defineEntityReplacementText( "Psi", "\u03a8" );
661             parser.defineEntityReplacementText( "Omega", "\u03a9" );
662             parser.defineEntityReplacementText( "alpha", "\u03b1" );
663             parser.defineEntityReplacementText( "beta", "\u03b2" );
664             parser.defineEntityReplacementText( "gamma", "\u03b3" );
665             parser.defineEntityReplacementText( "delta", "\u03b4" );
666             parser.defineEntityReplacementText( "epsilon", "\u03b5" );
667             parser.defineEntityReplacementText( "zeta", "\u03b6" );
668             parser.defineEntityReplacementText( "eta", "\u03b7" );
669             parser.defineEntityReplacementText( "theta", "\u03b8" );
670             parser.defineEntityReplacementText( "iota", "\u03b9" );
671             parser.defineEntityReplacementText( "kappa", "\u03ba" );
672             parser.defineEntityReplacementText( "lambda", "\u03bb" );
673             parser.defineEntityReplacementText( "mu", "\u03bc" );
674             parser.defineEntityReplacementText( "nu", "\u03bd" );
675             parser.defineEntityReplacementText( "xi", "\u03be" );
676             parser.defineEntityReplacementText( "omicron", "\u03bf" );
677             parser.defineEntityReplacementText( "pi", "\u03c0" );
678             parser.defineEntityReplacementText( "rho", "\u03c1" );
679             parser.defineEntityReplacementText( "sigmaf", "\u03c2" );
680             parser.defineEntityReplacementText( "sigma", "\u03c3" );
681             parser.defineEntityReplacementText( "tau", "\u03c4" );
682             parser.defineEntityReplacementText( "upsilon", "\u03c5" );
683             parser.defineEntityReplacementText( "phi", "\u03c6" );
684             parser.defineEntityReplacementText( "chi", "\u03c7" );
685             parser.defineEntityReplacementText( "psi", "\u03c8" );
686             parser.defineEntityReplacementText( "omega", "\u03c9" );
687             parser.defineEntityReplacementText( "thetasym", "\u03d1" );
688             parser.defineEntityReplacementText( "upsih", "\u03d2" );
689             parser.defineEntityReplacementText( "piv", "\u03d6" );
690             parser.defineEntityReplacementText( "bull", "\u2022" );
691             parser.defineEntityReplacementText( "hellip", "\u2026" );
692             parser.defineEntityReplacementText( "prime", "\u2032" );
693             parser.defineEntityReplacementText( "Prime", "\u2033" );
694             parser.defineEntityReplacementText( "oline", "\u203e" );
695             parser.defineEntityReplacementText( "frasl", "\u2044" );
696             parser.defineEntityReplacementText( "weierp", "\u2118" );
697             parser.defineEntityReplacementText( "image", "\u2111" );
698             parser.defineEntityReplacementText( "real", "\u211c" );
699             parser.defineEntityReplacementText( "trade", "\u2122" );
700             parser.defineEntityReplacementText( "alefsym", "\u2135" );
701             parser.defineEntityReplacementText( "larr", "\u2190" );
702             parser.defineEntityReplacementText( "uarr", "\u2191" );
703             parser.defineEntityReplacementText( "rarr", "\u2192" );
704             parser.defineEntityReplacementText( "darr", "\u2193" );
705             parser.defineEntityReplacementText( "harr", "\u2194" );
706             parser.defineEntityReplacementText( "crarr", "\u21b5" );
707             parser.defineEntityReplacementText( "lArr", "\u21d0" );
708             parser.defineEntityReplacementText( "uArr", "\u21d1" );
709             parser.defineEntityReplacementText( "rArr", "\u21d2" );
710             parser.defineEntityReplacementText( "dArr", "\u21d3" );
711             parser.defineEntityReplacementText( "hArr", "\u21d4" );
712             parser.defineEntityReplacementText( "forall", "\u2200" );
713             parser.defineEntityReplacementText( "part", "\u2202" );
714             parser.defineEntityReplacementText( "exist", "\u2203" );
715             parser.defineEntityReplacementText( "empty", "\u2205" );
716             parser.defineEntityReplacementText( "nabla", "\u2207" );
717             parser.defineEntityReplacementText( "isin", "\u2208" );
718             parser.defineEntityReplacementText( "notin", "\u2209" );
719             parser.defineEntityReplacementText( "ni", "\u220b" );
720             parser.defineEntityReplacementText( "prod", "\u220f" );
721             parser.defineEntityReplacementText( "sum", "\u2211" );
722             parser.defineEntityReplacementText( "minus", "\u2212" );
723             parser.defineEntityReplacementText( "lowast", "\u2217" );
724             parser.defineEntityReplacementText( "radic", "\u221a" );
725             parser.defineEntityReplacementText( "prop", "\u221d" );
726             parser.defineEntityReplacementText( "infin", "\u221e" );
727             parser.defineEntityReplacementText( "ang", "\u2220" );
728             parser.defineEntityReplacementText( "and", "\u2227" );
729             parser.defineEntityReplacementText( "or", "\u2228" );
730             parser.defineEntityReplacementText( "cap", "\u2229" );
731             parser.defineEntityReplacementText( "cup", "\u222a" );
732             parser.defineEntityReplacementText( "int", "\u222b" );
733             parser.defineEntityReplacementText( "there4", "\u2234" );
734             parser.defineEntityReplacementText( "sim", "\u223c" );
735             parser.defineEntityReplacementText( "cong", "\u2245" );
736             parser.defineEntityReplacementText( "asymp", "\u2248" );
737             parser.defineEntityReplacementText( "ne", "\u2260" );
738             parser.defineEntityReplacementText( "equiv", "\u2261" );
739             parser.defineEntityReplacementText( "le", "\u2264" );
740             parser.defineEntityReplacementText( "ge", "\u2265" );
741             parser.defineEntityReplacementText( "sub", "\u2282" );
742             parser.defineEntityReplacementText( "sup", "\u2283" );
743             parser.defineEntityReplacementText( "nsub", "\u2284" );
744             parser.defineEntityReplacementText( "sube", "\u2286" );
745             parser.defineEntityReplacementText( "supe", "\u2287" );
746             parser.defineEntityReplacementText( "oplus", "\u2295" );
747             parser.defineEntityReplacementText( "otimes", "\u2297" );
748             parser.defineEntityReplacementText( "perp", "\u22a5" );
749             parser.defineEntityReplacementText( "sdot", "\u22c5" );
750             parser.defineEntityReplacementText( "lceil", "\u2308" );
751             parser.defineEntityReplacementText( "rceil", "\u2309" );
752             parser.defineEntityReplacementText( "lfloor", "\u230a" );
753             parser.defineEntityReplacementText( "rfloor", "\u230b" );
754             parser.defineEntityReplacementText( "lang", "\u2329" );
755             parser.defineEntityReplacementText( "rang", "\u232a" );
756             parser.defineEntityReplacementText( "loz", "\u25ca" );
757             parser.defineEntityReplacementText( "spades", "\u2660" );
758             parser.defineEntityReplacementText( "clubs", "\u2663" );
759             parser.defineEntityReplacementText( "hearts", "\u2665" );
760             parser.defineEntityReplacementText( "diams", "\u2666" );
761 
762         }
763     } //-- void initParser( XmlPullParser )
764 
765     /**
766      * Method nextTag.
767      * 
768      * @param parser
769      * @throws IOException
770      * @throws XmlPullParserException
771      * @return int
772      */
773     private int nextTag( XmlPullParser parser )
774         throws IOException, XmlPullParserException
775     {
776         int eventType = parser.next();
777         if ( eventType == XmlPullParser.TEXT )
778         {
779             eventType = parser.next();
780         }
781         if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
782         {
783             throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
784         }
785         return eventType;
786     } //-- int nextTag( XmlPullParser )
787 
788     /**
789      * Method parseComponent.
790      * 
791      * @param parser
792      * @param strict
793      * @throws IOException
794      * @throws XmlPullParserException
795      * @return Component
796      */
797     private Component parseComponent( XmlPullParser parser, boolean strict )
798         throws IOException, XmlPullParserException
799     {
800         String tagName = parser.getName();
801         Component component = new Component();
802         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
803         {
804             String name = parser.getAttributeName( i );
805             String value = parser.getAttributeValue( i );
806 
807             if ( name.indexOf( ':' ) >= 0 )
808             {
809                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
810             }
811             else if ( "xmlns".equals( name ) )
812             {
813                 // ignore xmlns attribute in root class, which is a reserved attribute name
814             }
815             else
816             {
817                 checkUnknownAttribute( parser, name, tagName, strict );
818             }
819         }
820         java.util.Set parsed = new java.util.HashSet();
821         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
822         {
823             if ( checkFieldWithDuplicate( parser, "moduleSets", null, parsed ) )
824             {
825                 java.util.List moduleSets = new java.util.ArrayList/*<ModuleSet>*/();
826                 component.setModuleSets( moduleSets );
827                 while ( parser.nextTag() == XmlPullParser.START_TAG )
828                 {
829                     if ( "moduleSet".equals( parser.getName() ) )
830                     {
831                         moduleSets.add( parseModuleSet( parser, strict ) );
832                     }
833                     else
834                     {
835                         checkUnknownElement( parser, strict );
836                     }
837                 }
838             }
839             else if ( checkFieldWithDuplicate( parser, "fileSets", null, parsed ) )
840             {
841                 java.util.List fileSets = new java.util.ArrayList/*<FileSet>*/();
842                 component.setFileSets( fileSets );
843                 while ( parser.nextTag() == XmlPullParser.START_TAG )
844                 {
845                     if ( "fileSet".equals( parser.getName() ) )
846                     {
847                         fileSets.add( parseFileSet( parser, strict ) );
848                     }
849                     else
850                     {
851                         checkUnknownElement( parser, strict );
852                     }
853                 }
854             }
855             else if ( checkFieldWithDuplicate( parser, "files", null, parsed ) )
856             {
857                 java.util.List files = new java.util.ArrayList/*<FileItem>*/();
858                 component.setFiles( files );
859                 while ( parser.nextTag() == XmlPullParser.START_TAG )
860                 {
861                     if ( "file".equals( parser.getName() ) )
862                     {
863                         files.add( parseFileItem( parser, strict ) );
864                     }
865                     else
866                     {
867                         checkUnknownElement( parser, strict );
868                     }
869                 }
870             }
871             else if ( checkFieldWithDuplicate( parser, "dependencySets", null, parsed ) )
872             {
873                 java.util.List dependencySets = new java.util.ArrayList/*<DependencySet>*/();
874                 component.setDependencySets( dependencySets );
875                 while ( parser.nextTag() == XmlPullParser.START_TAG )
876                 {
877                     if ( "dependencySet".equals( parser.getName() ) )
878                     {
879                         dependencySets.add( parseDependencySet( parser, strict ) );
880                     }
881                     else
882                     {
883                         checkUnknownElement( parser, strict );
884                     }
885                 }
886             }
887             else if ( checkFieldWithDuplicate( parser, "repositories", null, parsed ) )
888             {
889                 java.util.List repositories = new java.util.ArrayList/*<Repository>*/();
890                 component.setRepositories( repositories );
891                 while ( parser.nextTag() == XmlPullParser.START_TAG )
892                 {
893                     if ( "repository".equals( parser.getName() ) )
894                     {
895                         repositories.add( parseRepository( parser, strict ) );
896                     }
897                     else
898                     {
899                         checkUnknownElement( parser, strict );
900                     }
901                 }
902             }
903             else if ( checkFieldWithDuplicate( parser, "containerDescriptorHandlers", null, parsed ) )
904             {
905                 java.util.List containerDescriptorHandlers = new java.util.ArrayList/*<ContainerDescriptorHandlerConfig>*/();
906                 component.setContainerDescriptorHandlers( containerDescriptorHandlers );
907                 while ( parser.nextTag() == XmlPullParser.START_TAG )
908                 {
909                     if ( "containerDescriptorHandler".equals( parser.getName() ) )
910                     {
911                         containerDescriptorHandlers.add( parseContainerDescriptorHandlerConfig( parser, strict ) );
912                     }
913                     else
914                     {
915                         checkUnknownElement( parser, strict );
916                     }
917                 }
918             }
919             else
920             {
921                 checkUnknownElement( parser, strict );
922             }
923         }
924         return component;
925     } //-- Component parseComponent( XmlPullParser, boolean )
926 
927     /**
928      * Method parseContainerDescriptorHandlerConfig.
929      * 
930      * @param parser
931      * @param strict
932      * @throws IOException
933      * @throws XmlPullParserException
934      * @return ContainerDescriptorHandlerConfig
935      */
936     private ContainerDescriptorHandlerConfig parseContainerDescriptorHandlerConfig( XmlPullParser parser, boolean strict )
937         throws IOException, XmlPullParserException
938     {
939         String tagName = parser.getName();
940         ContainerDescriptorHandlerConfig containerDescriptorHandlerConfig = new ContainerDescriptorHandlerConfig();
941         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
942         {
943             String name = parser.getAttributeName( i );
944             String value = parser.getAttributeValue( i );
945 
946             if ( name.indexOf( ':' ) >= 0 )
947             {
948                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
949             }
950             else
951             {
952                 checkUnknownAttribute( parser, name, tagName, strict );
953             }
954         }
955         java.util.Set parsed = new java.util.HashSet();
956         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
957         {
958             if ( checkFieldWithDuplicate( parser, "handlerName", null, parsed ) )
959             {
960                 containerDescriptorHandlerConfig.setHandlerName( getTrimmedValue( parser.nextText() ) );
961             }
962             else if ( checkFieldWithDuplicate( parser, "configuration", null, parsed ) )
963             {
964                 containerDescriptorHandlerConfig.setConfiguration( Xpp3DomBuilder.build( parser ) );
965             }
966             else
967             {
968                 checkUnknownElement( parser, strict );
969             }
970         }
971         return containerDescriptorHandlerConfig;
972     } //-- ContainerDescriptorHandlerConfig parseContainerDescriptorHandlerConfig( XmlPullParser, boolean )
973 
974     /**
975      * Method parseDependencySet.
976      * 
977      * @param parser
978      * @param strict
979      * @throws IOException
980      * @throws XmlPullParserException
981      * @return DependencySet
982      */
983     private DependencySet parseDependencySet( XmlPullParser parser, boolean strict )
984         throws IOException, XmlPullParserException
985     {
986         String tagName = parser.getName();
987         DependencySet dependencySet = new DependencySet();
988         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
989         {
990             String name = parser.getAttributeName( i );
991             String value = parser.getAttributeValue( i );
992 
993             if ( name.indexOf( ':' ) >= 0 )
994             {
995                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
996             }
997             else
998             {
999                 checkUnknownAttribute( parser, name, tagName, strict );
1000             }
1001         }
1002         java.util.Set parsed = new java.util.HashSet();
1003         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1004         {
1005             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1006             {
1007                 dependencySet.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1008             }
1009             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1010             {
1011                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1012                 dependencySet.setIncludes( includes );
1013                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1014                 {
1015                     if ( "include".equals( parser.getName() ) )
1016                     {
1017                         includes.add( getTrimmedValue( parser.nextText() ) );
1018                     }
1019                     else
1020                     {
1021                         checkUnknownElement( parser, strict );
1022                     }
1023                 }
1024             }
1025             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1026             {
1027                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1028                 dependencySet.setExcludes( excludes );
1029                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1030                 {
1031                     if ( "exclude".equals( parser.getName() ) )
1032                     {
1033                         excludes.add( getTrimmedValue( parser.nextText() ) );
1034                     }
1035                     else
1036                     {
1037                         checkUnknownElement( parser, strict );
1038                     }
1039                 }
1040             }
1041             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1042             {
1043                 dependencySet.setFileMode( getTrimmedValue( parser.nextText() ) );
1044             }
1045             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1046             {
1047                 dependencySet.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1048             }
1049             else if ( checkFieldWithDuplicate( parser, "useStrictFiltering", null, parsed ) )
1050             {
1051                 dependencySet.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText() ), "useStrictFiltering", parser, "false" ) );
1052             }
1053             else if ( checkFieldWithDuplicate( parser, "outputFileNameMapping", null, parsed ) )
1054             {
1055                 dependencySet.setOutputFileNameMapping( getTrimmedValue( parser.nextText() ) );
1056             }
1057             else if ( checkFieldWithDuplicate( parser, "unpack", null, parsed ) )
1058             {
1059                 dependencySet.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText() ), "unpack", parser, "false" ) );
1060             }
1061             else if ( checkFieldWithDuplicate( parser, "unpackOptions", null, parsed ) )
1062             {
1063                 dependencySet.setUnpackOptions( parseUnpackOptions( parser, strict ) );
1064             }
1065             else if ( checkFieldWithDuplicate( parser, "scope", null, parsed ) )
1066             {
1067                 dependencySet.setScope( getTrimmedValue( parser.nextText() ) );
1068             }
1069             else if ( checkFieldWithDuplicate( parser, "useProjectArtifact", null, parsed ) )
1070             {
1071                 dependencySet.setUseProjectArtifact( getBooleanValue( getTrimmedValue( parser.nextText() ), "useProjectArtifact", parser, "true" ) );
1072             }
1073             else if ( checkFieldWithDuplicate( parser, "useProjectAttachments", null, parsed ) )
1074             {
1075                 dependencySet.setUseProjectAttachments( getBooleanValue( getTrimmedValue( parser.nextText() ), "useProjectAttachments", parser, "false" ) );
1076             }
1077             else if ( checkFieldWithDuplicate( parser, "useTransitiveDependencies", null, parsed ) )
1078             {
1079                 dependencySet.setUseTransitiveDependencies( getBooleanValue( getTrimmedValue( parser.nextText() ), "useTransitiveDependencies", parser, "true" ) );
1080             }
1081             else if ( checkFieldWithDuplicate( parser, "useTransitiveFiltering", null, parsed ) )
1082             {
1083                 dependencySet.setUseTransitiveFiltering( getBooleanValue( getTrimmedValue( parser.nextText() ), "useTransitiveFiltering", parser, "false" ) );
1084             }
1085             else
1086             {
1087                 checkUnknownElement( parser, strict );
1088             }
1089         }
1090         return dependencySet;
1091     } //-- DependencySet parseDependencySet( XmlPullParser, boolean )
1092 
1093     /**
1094      * Method parseFileItem.
1095      * 
1096      * @param parser
1097      * @param strict
1098      * @throws IOException
1099      * @throws XmlPullParserException
1100      * @return FileItem
1101      */
1102     private FileItem parseFileItem( XmlPullParser parser, boolean strict )
1103         throws IOException, XmlPullParserException
1104     {
1105         String tagName = parser.getName();
1106         FileItem fileItem = new FileItem();
1107         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1108         {
1109             String name = parser.getAttributeName( i );
1110             String value = parser.getAttributeValue( i );
1111 
1112             if ( name.indexOf( ':' ) >= 0 )
1113             {
1114                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1115             }
1116             else
1117             {
1118                 checkUnknownAttribute( parser, name, tagName, strict );
1119             }
1120         }
1121         java.util.Set parsed = new java.util.HashSet();
1122         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1123         {
1124             if ( checkFieldWithDuplicate( parser, "source", null, parsed ) )
1125             {
1126                 fileItem.setSource( getTrimmedValue( parser.nextText() ) );
1127             }
1128             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1129             {
1130                 fileItem.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1131             }
1132             else if ( checkFieldWithDuplicate( parser, "destName", null, parsed ) )
1133             {
1134                 fileItem.setDestName( getTrimmedValue( parser.nextText() ) );
1135             }
1136             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1137             {
1138                 fileItem.setFileMode( getTrimmedValue( parser.nextText() ) );
1139             }
1140             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1141             {
1142                 fileItem.setLineEnding( getTrimmedValue( parser.nextText() ) );
1143             }
1144             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1145             {
1146                 fileItem.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1147             }
1148             else
1149             {
1150                 checkUnknownElement( parser, strict );
1151             }
1152         }
1153         return fileItem;
1154     } //-- FileItem parseFileItem( XmlPullParser, boolean )
1155 
1156     /**
1157      * Method parseFileSet.
1158      * 
1159      * @param parser
1160      * @param strict
1161      * @throws IOException
1162      * @throws XmlPullParserException
1163      * @return FileSet
1164      */
1165     private FileSet parseFileSet( XmlPullParser parser, boolean strict )
1166         throws IOException, XmlPullParserException
1167     {
1168         String tagName = parser.getName();
1169         FileSet fileSet = new FileSet();
1170         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1171         {
1172             String name = parser.getAttributeName( i );
1173             String value = parser.getAttributeValue( i );
1174 
1175             if ( name.indexOf( ':' ) >= 0 )
1176             {
1177                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1178             }
1179             else
1180             {
1181                 checkUnknownAttribute( parser, name, tagName, strict );
1182             }
1183         }
1184         java.util.Set parsed = new java.util.HashSet();
1185         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1186         {
1187             if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1188             {
1189                 fileSet.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1190             }
1191             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1192             {
1193                 fileSet.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1194             }
1195             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1196             {
1197                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1198                 fileSet.setIncludes( includes );
1199                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1200                 {
1201                     if ( "include".equals( parser.getName() ) )
1202                     {
1203                         includes.add( getTrimmedValue( parser.nextText() ) );
1204                     }
1205                     else
1206                     {
1207                         checkUnknownElement( parser, strict );
1208                     }
1209                 }
1210             }
1211             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1212             {
1213                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1214                 fileSet.setExcludes( excludes );
1215                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1216                 {
1217                     if ( "exclude".equals( parser.getName() ) )
1218                     {
1219                         excludes.add( getTrimmedValue( parser.nextText() ) );
1220                     }
1221                     else
1222                     {
1223                         checkUnknownElement( parser, strict );
1224                     }
1225                 }
1226             }
1227             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1228             {
1229                 fileSet.setFileMode( getTrimmedValue( parser.nextText() ) );
1230             }
1231             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1232             {
1233                 fileSet.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1234             }
1235             else if ( checkFieldWithDuplicate( parser, "directory", null, parsed ) )
1236             {
1237                 fileSet.setDirectory( getTrimmedValue( parser.nextText() ) );
1238             }
1239             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1240             {
1241                 fileSet.setLineEnding( getTrimmedValue( parser.nextText() ) );
1242             }
1243             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1244             {
1245                 fileSet.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1246             }
1247             else
1248             {
1249                 checkUnknownElement( parser, strict );
1250             }
1251         }
1252         return fileSet;
1253     } //-- FileSet parseFileSet( XmlPullParser, boolean )
1254 
1255     /**
1256      * Method parseGroupVersionAlignment.
1257      * 
1258      * @param parser
1259      * @param strict
1260      * @throws IOException
1261      * @throws XmlPullParserException
1262      * @return GroupVersionAlignment
1263      */
1264     private GroupVersionAlignment parseGroupVersionAlignment( XmlPullParser parser, boolean strict )
1265         throws IOException, XmlPullParserException
1266     {
1267         String tagName = parser.getName();
1268         GroupVersionAlignment groupVersionAlignment = new GroupVersionAlignment();
1269         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1270         {
1271             String name = parser.getAttributeName( i );
1272             String value = parser.getAttributeValue( i );
1273 
1274             if ( name.indexOf( ':' ) >= 0 )
1275             {
1276                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1277             }
1278             else
1279             {
1280                 checkUnknownAttribute( parser, name, tagName, strict );
1281             }
1282         }
1283         java.util.Set parsed = new java.util.HashSet();
1284         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1285         {
1286             if ( checkFieldWithDuplicate( parser, "id", null, parsed ) )
1287             {
1288                 groupVersionAlignment.setId( getTrimmedValue( parser.nextText() ) );
1289             }
1290             else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
1291             {
1292                 groupVersionAlignment.setVersion( getTrimmedValue( parser.nextText() ) );
1293             }
1294             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1295             {
1296                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1297                 groupVersionAlignment.setExcludes( excludes );
1298                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1299                 {
1300                     if ( "exclude".equals( parser.getName() ) )
1301                     {
1302                         excludes.add( getTrimmedValue( parser.nextText() ) );
1303                     }
1304                     else
1305                     {
1306                         checkUnknownElement( parser, strict );
1307                     }
1308                 }
1309             }
1310             else
1311             {
1312                 checkUnknownElement( parser, strict );
1313             }
1314         }
1315         return groupVersionAlignment;
1316     } //-- GroupVersionAlignment parseGroupVersionAlignment( XmlPullParser, boolean )
1317 
1318     /**
1319      * Method parseModuleBinaries.
1320      * 
1321      * @param parser
1322      * @param strict
1323      * @throws IOException
1324      * @throws XmlPullParserException
1325      * @return ModuleBinaries
1326      */
1327     private ModuleBinaries parseModuleBinaries( XmlPullParser parser, boolean strict )
1328         throws IOException, XmlPullParserException
1329     {
1330         String tagName = parser.getName();
1331         ModuleBinaries moduleBinaries = new ModuleBinaries();
1332         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1333         {
1334             String name = parser.getAttributeName( i );
1335             String value = parser.getAttributeValue( i );
1336 
1337             if ( name.indexOf( ':' ) >= 0 )
1338             {
1339                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1340             }
1341             else
1342             {
1343                 checkUnknownAttribute( parser, name, tagName, strict );
1344             }
1345         }
1346         java.util.Set parsed = new java.util.HashSet();
1347         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1348         {
1349             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1350             {
1351                 moduleBinaries.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1352             }
1353             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1354             {
1355                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1356                 moduleBinaries.setIncludes( includes );
1357                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1358                 {
1359                     if ( "include".equals( parser.getName() ) )
1360                     {
1361                         includes.add( getTrimmedValue( parser.nextText() ) );
1362                     }
1363                     else
1364                     {
1365                         checkUnknownElement( parser, strict );
1366                     }
1367                 }
1368             }
1369             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1370             {
1371                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1372                 moduleBinaries.setExcludes( excludes );
1373                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1374                 {
1375                     if ( "exclude".equals( parser.getName() ) )
1376                     {
1377                         excludes.add( getTrimmedValue( parser.nextText() ) );
1378                     }
1379                     else
1380                     {
1381                         checkUnknownElement( parser, strict );
1382                     }
1383                 }
1384             }
1385             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1386             {
1387                 moduleBinaries.setFileMode( getTrimmedValue( parser.nextText() ) );
1388             }
1389             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1390             {
1391                 moduleBinaries.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1392             }
1393             else if ( checkFieldWithDuplicate( parser, "attachmentClassifier", null, parsed ) )
1394             {
1395                 moduleBinaries.setAttachmentClassifier( getTrimmedValue( parser.nextText() ) );
1396             }
1397             else if ( checkFieldWithDuplicate( parser, "includeDependencies", null, parsed ) )
1398             {
1399                 moduleBinaries.setIncludeDependencies( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeDependencies", parser, "true" ) );
1400             }
1401             else if ( checkFieldWithDuplicate( parser, "dependencySets", null, parsed ) )
1402             {
1403                 java.util.List dependencySets = new java.util.ArrayList/*<DependencySet>*/();
1404                 moduleBinaries.setDependencySets( dependencySets );
1405                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1406                 {
1407                     if ( "dependencySet".equals( parser.getName() ) )
1408                     {
1409                         dependencySets.add( parseDependencySet( parser, strict ) );
1410                     }
1411                     else
1412                     {
1413                         checkUnknownElement( parser, strict );
1414                     }
1415                 }
1416             }
1417             else if ( checkFieldWithDuplicate( parser, "unpack", null, parsed ) )
1418             {
1419                 moduleBinaries.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText() ), "unpack", parser, "true" ) );
1420             }
1421             else if ( checkFieldWithDuplicate( parser, "unpackOptions", null, parsed ) )
1422             {
1423                 moduleBinaries.setUnpackOptions( parseUnpackOptions( parser, strict ) );
1424             }
1425             else if ( checkFieldWithDuplicate( parser, "outputFileNameMapping", null, parsed ) )
1426             {
1427                 moduleBinaries.setOutputFileNameMapping( getTrimmedValue( parser.nextText() ) );
1428             }
1429             else
1430             {
1431                 checkUnknownElement( parser, strict );
1432             }
1433         }
1434         return moduleBinaries;
1435     } //-- ModuleBinaries parseModuleBinaries( XmlPullParser, boolean )
1436 
1437     /**
1438      * Method parseModuleSet.
1439      * 
1440      * @param parser
1441      * @param strict
1442      * @throws IOException
1443      * @throws XmlPullParserException
1444      * @return ModuleSet
1445      */
1446     private ModuleSet parseModuleSet( XmlPullParser parser, boolean strict )
1447         throws IOException, XmlPullParserException
1448     {
1449         String tagName = parser.getName();
1450         ModuleSet moduleSet = new ModuleSet();
1451         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1452         {
1453             String name = parser.getAttributeName( i );
1454             String value = parser.getAttributeValue( i );
1455 
1456             if ( name.indexOf( ':' ) >= 0 )
1457             {
1458                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1459             }
1460             else
1461             {
1462                 checkUnknownAttribute( parser, name, tagName, strict );
1463             }
1464         }
1465         java.util.Set parsed = new java.util.HashSet();
1466         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1467         {
1468             if ( checkFieldWithDuplicate( parser, "useAllReactorProjects", null, parsed ) )
1469             {
1470                 moduleSet.setUseAllReactorProjects( getBooleanValue( getTrimmedValue( parser.nextText() ), "useAllReactorProjects", parser, "false" ) );
1471             }
1472             else if ( checkFieldWithDuplicate( parser, "includeSubModules", null, parsed ) )
1473             {
1474                 moduleSet.setIncludeSubModules( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeSubModules", parser, "true" ) );
1475             }
1476             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1477             {
1478                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1479                 moduleSet.setIncludes( includes );
1480                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1481                 {
1482                     if ( "include".equals( parser.getName() ) )
1483                     {
1484                         includes.add( getTrimmedValue( parser.nextText() ) );
1485                     }
1486                     else
1487                     {
1488                         checkUnknownElement( parser, strict );
1489                     }
1490                 }
1491             }
1492             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1493             {
1494                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1495                 moduleSet.setExcludes( excludes );
1496                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1497                 {
1498                     if ( "exclude".equals( parser.getName() ) )
1499                     {
1500                         excludes.add( getTrimmedValue( parser.nextText() ) );
1501                     }
1502                     else
1503                     {
1504                         checkUnknownElement( parser, strict );
1505                     }
1506                 }
1507             }
1508             else if ( checkFieldWithDuplicate( parser, "sources", null, parsed ) )
1509             {
1510                 moduleSet.setSources( parseModuleSources( parser, strict ) );
1511             }
1512             else if ( checkFieldWithDuplicate( parser, "binaries", null, parsed ) )
1513             {
1514                 moduleSet.setBinaries( parseModuleBinaries( parser, strict ) );
1515             }
1516             else
1517             {
1518                 checkUnknownElement( parser, strict );
1519             }
1520         }
1521         return moduleSet;
1522     } //-- ModuleSet parseModuleSet( XmlPullParser, boolean )
1523 
1524     /**
1525      * Method parseModuleSources.
1526      * 
1527      * @param parser
1528      * @param strict
1529      * @throws IOException
1530      * @throws XmlPullParserException
1531      * @return ModuleSources
1532      */
1533     private ModuleSources parseModuleSources( XmlPullParser parser, boolean strict )
1534         throws IOException, XmlPullParserException
1535     {
1536         String tagName = parser.getName();
1537         ModuleSources moduleSources = new ModuleSources();
1538         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1539         {
1540             String name = parser.getAttributeName( i );
1541             String value = parser.getAttributeValue( i );
1542 
1543             if ( name.indexOf( ':' ) >= 0 )
1544             {
1545                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1546             }
1547             else
1548             {
1549                 checkUnknownAttribute( parser, name, tagName, strict );
1550             }
1551         }
1552         java.util.Set parsed = new java.util.HashSet();
1553         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1554         {
1555             if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1556             {
1557                 moduleSources.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1558             }
1559             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1560             {
1561                 moduleSources.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1562             }
1563             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1564             {
1565                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1566                 moduleSources.setIncludes( includes );
1567                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1568                 {
1569                     if ( "include".equals( parser.getName() ) )
1570                     {
1571                         includes.add( getTrimmedValue( parser.nextText() ) );
1572                     }
1573                     else
1574                     {
1575                         checkUnknownElement( parser, strict );
1576                     }
1577                 }
1578             }
1579             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1580             {
1581                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1582                 moduleSources.setExcludes( excludes );
1583                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1584                 {
1585                     if ( "exclude".equals( parser.getName() ) )
1586                     {
1587                         excludes.add( getTrimmedValue( parser.nextText() ) );
1588                     }
1589                     else
1590                     {
1591                         checkUnknownElement( parser, strict );
1592                     }
1593                 }
1594             }
1595             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1596             {
1597                 moduleSources.setFileMode( getTrimmedValue( parser.nextText() ) );
1598             }
1599             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1600             {
1601                 moduleSources.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1602             }
1603             else if ( checkFieldWithDuplicate( parser, "fileSets", null, parsed ) )
1604             {
1605                 java.util.List fileSets = new java.util.ArrayList/*<FileSet>*/();
1606                 moduleSources.setFileSets( fileSets );
1607                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1608                 {
1609                     if ( "fileSet".equals( parser.getName() ) )
1610                     {
1611                         fileSets.add( parseFileSet( parser, strict ) );
1612                     }
1613                     else
1614                     {
1615                         checkUnknownElement( parser, strict );
1616                     }
1617                 }
1618             }
1619             else if ( checkFieldWithDuplicate( parser, "includeModuleDirectory", null, parsed ) )
1620             {
1621                 moduleSources.setIncludeModuleDirectory( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeModuleDirectory", parser, "true" ) );
1622             }
1623             else if ( checkFieldWithDuplicate( parser, "excludeSubModuleDirectories", null, parsed ) )
1624             {
1625                 moduleSources.setExcludeSubModuleDirectories( getBooleanValue( getTrimmedValue( parser.nextText() ), "excludeSubModuleDirectories", parser, "true" ) );
1626             }
1627             else if ( checkFieldWithDuplicate( parser, "outputDirectoryMapping", null, parsed ) )
1628             {
1629                 moduleSources.setOutputDirectoryMapping( getTrimmedValue( parser.nextText() ) );
1630             }
1631             else
1632             {
1633                 checkUnknownElement( parser, strict );
1634             }
1635         }
1636         return moduleSources;
1637     } //-- ModuleSources parseModuleSources( XmlPullParser, boolean )
1638 
1639     /**
1640      * Method parseRepository.
1641      * 
1642      * @param parser
1643      * @param strict
1644      * @throws IOException
1645      * @throws XmlPullParserException
1646      * @return Repository
1647      */
1648     private Repository parseRepository( XmlPullParser parser, boolean strict )
1649         throws IOException, XmlPullParserException
1650     {
1651         String tagName = parser.getName();
1652         Repository repository = new Repository();
1653         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1654         {
1655             String name = parser.getAttributeName( i );
1656             String value = parser.getAttributeValue( i );
1657 
1658             if ( name.indexOf( ':' ) >= 0 )
1659             {
1660                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1661             }
1662             else
1663             {
1664                 checkUnknownAttribute( parser, name, tagName, strict );
1665             }
1666         }
1667         java.util.Set parsed = new java.util.HashSet();
1668         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1669         {
1670             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1671             {
1672                 repository.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1673             }
1674             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1675             {
1676                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1677                 repository.setIncludes( includes );
1678                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1679                 {
1680                     if ( "include".equals( parser.getName() ) )
1681                     {
1682                         includes.add( getTrimmedValue( parser.nextText() ) );
1683                     }
1684                     else
1685                     {
1686                         checkUnknownElement( parser, strict );
1687                     }
1688                 }
1689             }
1690             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1691             {
1692                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1693                 repository.setExcludes( excludes );
1694                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1695                 {
1696                     if ( "exclude".equals( parser.getName() ) )
1697                     {
1698                         excludes.add( getTrimmedValue( parser.nextText() ) );
1699                     }
1700                     else
1701                     {
1702                         checkUnknownElement( parser, strict );
1703                     }
1704                 }
1705             }
1706             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1707             {
1708                 repository.setFileMode( getTrimmedValue( parser.nextText() ) );
1709             }
1710             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1711             {
1712                 repository.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1713             }
1714             else if ( checkFieldWithDuplicate( parser, "includeMetadata", null, parsed ) )
1715             {
1716                 repository.setIncludeMetadata( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeMetadata", parser, "false" ) );
1717             }
1718             else if ( checkFieldWithDuplicate( parser, "groupVersionAlignments", null, parsed ) )
1719             {
1720                 java.util.List groupVersionAlignments = new java.util.ArrayList/*<GroupVersionAlignment>*/();
1721                 repository.setGroupVersionAlignments( groupVersionAlignments );
1722                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1723                 {
1724                     if ( "groupVersionAlignment".equals( parser.getName() ) )
1725                     {
1726                         groupVersionAlignments.add( parseGroupVersionAlignment( parser, strict ) );
1727                     }
1728                     else
1729                     {
1730                         checkUnknownElement( parser, strict );
1731                     }
1732                 }
1733             }
1734             else if ( checkFieldWithDuplicate( parser, "scope", null, parsed ) )
1735             {
1736                 repository.setScope( getTrimmedValue( parser.nextText() ) );
1737             }
1738             else
1739             {
1740                 checkUnknownElement( parser, strict );
1741             }
1742         }
1743         return repository;
1744     } //-- Repository parseRepository( XmlPullParser, boolean )
1745 
1746     /**
1747      * Method parseUnpackOptions.
1748      * 
1749      * @param parser
1750      * @param strict
1751      * @throws IOException
1752      * @throws XmlPullParserException
1753      * @return UnpackOptions
1754      */
1755     private UnpackOptions parseUnpackOptions( XmlPullParser parser, boolean strict )
1756         throws IOException, XmlPullParserException
1757     {
1758         String tagName = parser.getName();
1759         UnpackOptions unpackOptions = new UnpackOptions();
1760         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1761         {
1762             String name = parser.getAttributeName( i );
1763             String value = parser.getAttributeValue( i );
1764 
1765             if ( name.indexOf( ':' ) >= 0 )
1766             {
1767                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1768             }
1769             else
1770             {
1771                 checkUnknownAttribute( parser, name, tagName, strict );
1772             }
1773         }
1774         java.util.Set parsed = new java.util.HashSet();
1775         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1776         {
1777             if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1778             {
1779                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1780                 unpackOptions.setIncludes( includes );
1781                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1782                 {
1783                     if ( "include".equals( parser.getName() ) )
1784                     {
1785                         includes.add( getTrimmedValue( parser.nextText() ) );
1786                     }
1787                     else
1788                     {
1789                         checkUnknownElement( parser, strict );
1790                     }
1791                 }
1792             }
1793             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1794             {
1795                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1796                 unpackOptions.setExcludes( excludes );
1797                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1798                 {
1799                     if ( "exclude".equals( parser.getName() ) )
1800                     {
1801                         excludes.add( getTrimmedValue( parser.nextText() ) );
1802                     }
1803                     else
1804                     {
1805                         checkUnknownElement( parser, strict );
1806                     }
1807                 }
1808             }
1809             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1810             {
1811                 unpackOptions.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1812             }
1813             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1814             {
1815                 unpackOptions.setLineEnding( getTrimmedValue( parser.nextText() ) );
1816             }
1817             else if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1818             {
1819                 unpackOptions.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1820             }
1821             else
1822             {
1823                 checkUnknownElement( parser, strict );
1824             }
1825         }
1826         return unpackOptions;
1827     } //-- UnpackOptions parseUnpackOptions( XmlPullParser, boolean )
1828 
1829     /**
1830      * @see ReaderFactory#newXmlReader
1831      * 
1832      * @param reader
1833      * @param strict
1834      * @throws IOException
1835      * @throws XmlPullParserException
1836      * @return Component
1837      */
1838     public Component read( Reader reader, boolean strict )
1839         throws IOException, XmlPullParserException
1840     {
1841         XmlPullParser parser = new MXParser();
1842 
1843         parser.setInput( reader );
1844 
1845         initParser( parser );
1846 
1847         return read( parser, strict );
1848     } //-- Component read( Reader, boolean )
1849 
1850     /**
1851      * @see ReaderFactory#newXmlReader
1852      * 
1853      * @param reader
1854      * @throws IOException
1855      * @throws XmlPullParserException
1856      * @return Component
1857      */
1858     public Component read( Reader reader )
1859         throws IOException, XmlPullParserException
1860     {
1861         return read( reader, true );
1862     } //-- Component read( Reader )
1863 
1864     /**
1865      * Method read.
1866      * 
1867      * @param in
1868      * @param strict
1869      * @throws IOException
1870      * @throws XmlPullParserException
1871      * @return Component
1872      */
1873     public Component read( InputStream in, boolean strict )
1874         throws IOException, XmlPullParserException
1875     {
1876         return read( ReaderFactory.newXmlReader( in ), strict );
1877     } //-- Component read( InputStream, boolean )
1878 
1879     /**
1880      * Method read.
1881      * 
1882      * @param in
1883      * @throws IOException
1884      * @throws XmlPullParserException
1885      * @return Component
1886      */
1887     public Component read( InputStream in )
1888         throws IOException, XmlPullParserException
1889     {
1890         return read( ReaderFactory.newXmlReader( in ) );
1891     } //-- Component read( InputStream )
1892 
1893     /**
1894      * Method read.
1895      * 
1896      * @param parser
1897      * @param strict
1898      * @throws IOException
1899      * @throws XmlPullParserException
1900      * @return Component
1901      */
1902     private Component read( XmlPullParser parser, boolean strict )
1903         throws IOException, XmlPullParserException
1904     {
1905         int eventType = parser.getEventType();
1906         while ( eventType != XmlPullParser.END_DOCUMENT )
1907         {
1908             if ( eventType == XmlPullParser.START_TAG )
1909             {
1910                 if ( strict && ! "component".equals( parser.getName() ) )
1911                 {
1912                     throw new XmlPullParserException( "Expected root element 'component' but found '" + parser.getName() + "'", parser, null );
1913                 }
1914                 Component component = parseComponent( parser, strict );
1915                 component.setModelEncoding( parser.getInputEncoding() );
1916                 return component;
1917             }
1918             eventType = parser.next();
1919         }
1920         throw new XmlPullParserException( "Expected root element 'component' but found no element at all: invalid XML document", parser, null );
1921     } //-- Component read( XmlPullParser, boolean )
1922 
1923     /**
1924      * Sets the state of the "add default entities" flag.
1925      * 
1926      * @param addDefaultEntities
1927      */
1928     public void setAddDefaultEntities( boolean addDefaultEntities )
1929     {
1930         this.addDefaultEntities = addDefaultEntities;
1931     } //-- void setAddDefaultEntities( boolean )
1932 
1933 }